DEV Community: Chukwuemeka Igbokwe

Chuks, A New Programming Language That Outperforms Go on HTTP Throughput

Chukwuemeka Igbokwe — Wed, 18 Mar 2026 19:50:01 +0000

Hi i've been building a programming language called Chuks, and it just hit v0.0.6. Here's why I think it's worth your attention.

What is Chuks?
Chuks bridges scripting-language simplicity with compiled-language performance. Think TypeScript's developer experience, Go's deployment model, and a runtime that's faster than both.

It ships as a single binary with a VM, AOT compiler, built-in HTTP server, 4 SQL database drivers, structured concurrency, and 30+ standard library modules — all included, no packages required.

import { createServer, Request, Response } from "std/http"

var app = createServer()

app.get("/", function(req: Request, res: Response) {
    res.json('{"status": "ok"}')
})

app.listen(3000)

That's a production-grade, multi-threaded HTTP server in 8 lines.

The Numbers

Chuks beats Go on Fibonacci, matches it on N-Body, and is 2–5x faster than Java and Node.js across the board. It's 60–255x faster than Python.

How?
Chuks compiles to Go source via AOT, then to native machine code. The AOT compiler produces devirtualized method dispatch, typed arithmetic, and zero-cost nil checks — code that's nearly identical to hand-written Go.

It handles requests across all CPU cores by default.

What Makes Chuks Different
Dual execution modes. Run with chuks run (VM for rapid development) or build with chuks build (AOT for production). No other language offers both.

True structured concurrency. spawn runs any function in parallel. async/await handles I/O. Parent task cancellation automatically cascades to children — no leaked Promises, no dangling goroutines.

async function handleRequest(req: Request, res: Response):Task<void>{
    var userTask: Task<any> = spawn fetchUser(req.params["id"])
    var ordersTask: Task<any> = spawn fetchOrders(req.params["id"])

    var user: any = await userTask
    var orders: any = await ordersTask

    res.json({ "user": user, "orders": orders })
}

Batteries included. The standard library covers HTTP, JSON, JWT, crypto, validation, rate limiting, UUID, regex, logging, channels, TCP/TLS, file I/O, and 4 built-in SQL drivers (SQLite, PostgreSQL, MySQL, MSSQL).

Growing package ecosystem. Redis, Kafka, RabbitMQ, MongoDB, Elasticsearch, gRPC, NATS, WebSocket, S3, SMTP, GraphQL, OpenAPI, OAuth, OpenTelemetry, cron, CSV, XML, YAML — all available as packages.

Tooling from day one. VS Code extension with syntax highlighting, LSP, and snippets. Built-in debugger (DAP). REPL. Self-updating CLI with chuks upgrade.

Get Started

# Install (macOS/Linux/Windows)
curl -fsSL https://raw.githubusercontent.com/chuks-programming-language/releases/main/install.sh | bash

# Create a project
chuks new my_app
cd my_app
chuks run src/main.chuks

# Build for production
chuks build src/main.chuks
./build/main.chuks.bin

X: @Chukslang
Website: chuks.org
GitHub: github.com/chuks-programming-language

Chuks is still early (v0.0.6), but the foundation is solid — 157 tests passing, cross-platform releases (macOS, Linux, Windows), and real-world projects already running on it.

I'd love feedback. What would you want from a language like this?

ExpressWebJs 4 is now released!

Chukwuemeka Igbokwe — Wed, 21 Sep 2022 17:17:22 +0000

ExpressWebJs version 4 is now released and it includes many new features, including:

Mongoose and ObjectionJs ORM support.
SQL database relationship addons.
Multi-tenancy support for mongo DB.
Route match.
Route redirect.
Improved middleware handler methods.
Improved service registry handlers.
Custom validation rules.
Improved event class generation.
Added Redis to the supported queue connections.
Service communication for distributed services.
Domain-driven design (DDD).
Support for Restana platform service for faster request processing.
New utility features like Optional( ),ObjectMapper( ), FirstCharacterToLowerCase( ), Group( ), ObjectHasProperty( ).
New Collection feature which helps you work on advanced data structures and algorithms.

ExpressWebJs uses a variety of community driven packages for a number of features in the framework.

ExpressWebJs version 4 will receive bug fixes until November 2023 and security fixes until February 2024. Here are some of the features that we’ve covered in detail.

We’ve added some relationship add-ons for the SQL database model.
The relationship mapping method now has a nice way of handling relationships with the new hasMany, belongsTo, hasOne, hasOneThrough, hasManyThrough methods that also accept additional options.

hasManyThrough()

 export class UserModel extends Model {
  static tableName = "users";

  id!: string;
  name!: string;
  email!: string;
  password!: string;

  static relationMappings() {
    return {
      carOwner: this.hasManyThrough("App/Model/Cars_model",
      "App/Model/CarOwners_model", {
        join_final_foreign_key: "user_id",
        join_parent_foreign_key: "car_id",
      }),
    };
  }
}

hasOneThrough()

 export class UserModel extends Model {
  static tableName = "users";

  id!: string;
  name!: string;
  email!: string;
  password!: string;

  static relationMappings() {
    return {
      carOwner: this.hasOneThrough("App/Model/Cars_model", 
        "App/Model/CarOwners_model", {
        join_final_foreign_key: "user_id",
        join_parent_foreign_key: "car_id",
      }),
    };
  }
}

hasOne()

export class UserModel extends Model {
  static tableName = "users";

  id!: string;
  first_name!: string;
  last_name!: string;
  email!: string;
  password!: string;

  static relationMappings() {
    return {
      profile: this.hasOne("App/Model/Profile_model"),
    };
  }
}

hasMany()

export class UserModel extends Model {
  static tableName = "users";

  id!: string;
  first_name!: string;
  last_name!: string;
  email!: string;
  password!: string;

  static relationMappings() {
    return {
      profile: this.hasMany("App/Model/Cars_model"),
    };
  }
}

belongsTo()

export class Posts extends Model {
  static tableName = "posts";

  id!: string;
  name!: string;
  user_id!: string;

  static relationMappings() {
    return {
      users: this.belongsTo("App/Model/Users_model"),
    };
  }
}

Relation filters
You can also add some filters to your relationship mapping:

static relationMappings() {
    return {
      profile: this.hasMany("App/Model/Cars_model",{
        filter: (builder) => {
          builder.where("name", "Mercedes");
        },
      }),
    };
  }

Some route features are also added

Route Match
Sometimes you may need to register a route that responds to multiple HTTP verbs. You may do so using the match method. Or, you may even register a route that responds to all HTTP verbs using the all method:

  Route.match(["get", "post"], "/books", 
        "UserController@process");

Route Redirect
If you are defining a route that redirects to another URI, you may use the Route redirect method. This method provides a convenient shortcut so that you do not have to define a full route or controller for performing this task.

 Route.redirect("source_url", "destination_url");

You can see the complete list of new features and updates on ExpressWebJs website.

Kindly follow ExpressWebJs on twitter.

And don't forget to star on github.

You can also join the discord channel

Dependency Injection in ExpressWebJs V3

Chukwuemeka Igbokwe — Sun, 17 Oct 2021 11:42:51 +0000

In software engineering, dependency injection is a technique in which an object receives other objects that it depends on, called dependencies.

Typically, the receiving object is called a client and the passed-in ('injected') object is called a service.

The code that passes the service to the client is called the injector. Instead of the client specifying which service it will use, the injector tells the client what service to use. The 'injection' refers to the passing of a dependency (a service) into the client that uses it.

We can inject the classes into another class’s constructor and then get the object of that class, and through that object, we can access its methods and properties.

ExpressWebJs Dependency Injection

The Service Container in ExpressWebJs is a Dependency Injection Container and a registry for the application.

ExpressWebJs Container is a powerful tool for managing dependencies and stores objects for various purposes.

First let's create our Service and register it in App/Providers/AppServiceProvider.ts register method:

UserServiceInterface:

interface UserServiceInterface {
  createUser(user: object): Promise<UserObject>;
  findUserById(id: string): Promise<UserObject>;
}
export default UserServiceInterface;

UserService:


import Users from "App/Model/Users_model";
import UserServiceInterface from "./UserServicerInterface";

class UserService implements UserServiceInterface {
  async findUserById(id: string): Promise<object> {
    return await new Promise(async (resolve, reject) => {
      try {
        let user = await Users.query().findById(id);
        resolve(user);
      } catch (error) {
        reject(error);
      }
    });
  }

  async createUser(user: object): Promise<object> {
    return await new Promise(async (resolve, reject) => {
        try {
          let result = await Users.query().insert(user);
          resolve(result);
        } catch (error) {
          reject(error);
        }
      });
  }
}

export default UserService;

Now we register UserService in App/Providers/AppServiceProvider.ts register method:

import ServiceProvider from "Elucidate/Support/ServiceProvider";
import UserService from "App/Service/UserService";

class AppServiceProvicer extends ServiceProvider {
  /**
   * Register any application services.
   * @return void
   */
  public register() {
     this.app.singleton("UserService", UserService, "class");
  }
}

We can now inject our UserService into UserController Constructor:

"use strict";
import UserServiceInterface from "App/Service/UserService/UserServicerInterface";
import { Request, Response, NextFunction } from "Elucidate/HttpContext";
import HttpResponse from "Elucidate/HttpContext/ResponseType";

class UserController {
  protected userService: UserServiceInterface;

  constructor(UserService: UserServiceInterface) {
    this.userService = UserService;
  }

  /**
   * Display the specified resource.
   * @method GET
   * @endpoint api/user/get_user/:id
   * @param Request
   * @return Response
   */
  show = async (req: Request, res: Response, next: NextFunction) => {
    try {
      let user = await this.userService.findUserById(req.params.id);
      return HttpResponse.OK(res, user);
    } catch (error) {
      return next(error);
    }
  };
}

export default UserController;

In this example, the UserController needs to retrieve a user by id from a data source. So, we injected our service (UserService) that is able to retrieve users.

I hope this is helpful.

Kindly visit Expresswebjs Docs for documentation and usage.

Join ExpressWebJs community on Discord

You can follow ExpressWebJs on twitter @expresswebjs

And don't forget to star ExpressWebJs Project on Github
ExpressWebJs Javascript Version

ExpressWebJs Typescript Version

ExpressWebJs 3.2 Released

Chukwuemeka Igbokwe — Sun, 19 Sep 2021 22:57:35 +0000

The ExpressWebJs team have released 3.2 with auto endpoint documentation, and improvement in service injection.

Auto Endpoint Documentation:

Reference documentation for API endpoints consists of five general sections: resource descriptions, endpoints and methods, parameters, sample requests, and sample responses and schemas. All these are auto documented for you while you code, to allow you focus on building your amazing application.

To get started, install ExpressWebJs by running the command below

 npx expresswebcli new MyApplication --ts

and run 'npm install' to install the node packages 📦. Then create few endpoints and visit your base url in a browser followed by /documentationView for HTML view or /documentationJson for JSON.

Example: http://127.0.0.1:5000/documentationView or http://127.0.0.1:5000/documentationJson.

Service Injection

You can now inject services irrespective of the order in the application context.

In our Application Service Provider register method, we've registered some services.


  public register() {
    this.app.singleton("UserService", UserService, "class");
    this.app.singleton("CompanyService", CompanyService, "class");
    this.app.singleton("FolderService", FolderService, "class");
  }

Now we can inject UserService into FolderService like so:


import FolderRepository from "App/Repository/FolderRepository";
import BaseService from "../BaseService";
import IFolderService from "./IFolderService";
import IUserService from "./IUserService";

class FolderService extends BaseService implements
  protected userService:IUserService

  constructor(UserService:IUserService){
    this.userService = UserService
  }

 IFolderService {
  async getSubFolders(user_id: string): Promise<object> {
    return await new Promise(async (resolve, reject) => {
      try {
        let data = await new userService().findById(user_id);
        ...
      } catch (error: any) {
        ...
      }
    });
  }
}

You can join ExpressWebJs community on Discord and don't forget to give us a star on github
ExpressWebJs Javascript and ExpressWebJs Typescript

ExpressWebJs Maintenance Mode

Chukwuemeka Igbokwe — Mon, 16 Aug 2021 03:15:22 +0000

In this tutorial, I will show you how to switch your ExpressWebJs application to maintenance mode, and also how to change the default ExpressWebJs maintenance mode message to your custom message.

More often than not you would need to perform some maintenance for your ExpressWebJs application, luckily ExpressWebJs makes it super easy to put your application in maintenance mode.

You can switch your application to maintenance mode in Config/app.ts file.

 /*
  |-----------------------------------------------------------
  | Application maintenance mode
  |-----------------------------------------------------------
  | Mode ==> Determine if application is in maintenance mode 
  |    or not. Default value is false
  | Message ==> The message to render while in maintenance 
  |    mode.
  | Retry ==> The number of seconds after which the request 
  |    may be retried
  | Endpoints ==> The endPoints that should be reachable while 
  |    maintenance mode is enabled.
  |    endpoints example: ['api/users','api/accounts']
  |
*/
  maintenanceMode: {
    mode: true, //enable and disable maintenance mode
    message: "Application is in maintenance mode.",
    retry: 50,
    endPoints: [],
  },

When your application is in maintenance mode, a default message "Application is in maintenance mode" will be sent as a response to all requests accessing your application. This makes it easy to "disable" your application on downtime.

This downtime could be for a lot of reasons, including but not limited to:

Bugs.
Database error.
Migration to another server.
Server upgrade.
Decoupling to a new architecture.
SSL Error.
Updating Application etc.

A maintenance mode check is included in the default middleware stack for your application. If the application is in maintenance mode, a MaintenanceModeException will be thrown with a status code of 503.

To read more about ExpressWebJs, visit the Documentation site at ExpressWebJs .
You can also join the Discord community

You can follow me on twitter @EmekaIgbokwe
You can follow ExpressWebJs on twitter @expresswebjs
and don't forget to star on github ExpressWebJs

Please, let me know if you have any questions in the comment section. 😊

ExpressWebJs 3 Is Now Released!

Chukwuemeka Igbokwe — Fri, 13 Aug 2021 22:59:03 +0000

ExpressWebJs team is proud to announce the release of ExpressWebJs 3 and it’s now available to everyone. This release marks the start of the ExpressWebJs framework using Typescript.

Also, this release includes improved authentication and authorization responses, job, middleware, route collections, sub-query improvements, among many other improvements.

Here are some of the new features included in ExpressWebJs 3:

Model Types for SQL and NOSQL
Maker Command
Persistent Repository
Multi Tenancy
Social Authentication
Encryption
Hashing
Route Groups and middleware
Request Validation (Inline and external)
Dependency Injection
Service Providers
Events And Listeners
Queues
Task Schedulers
Web Socket

Please visit Expresswebjs Docs for documentation and usage.

Thanks to everyone who have contributed with issue reports and pull requests. Our next set of releases are due March 19, 2022.

How can you help?
If you’re interested in helping out, or if you have general questions, please ask on stackoverflow.com using the ExpressWebJs tag or chat with the community on Discord

JWT authentication in Expresswebjs

Chukwuemeka Igbokwe — Sun, 07 Mar 2021 10:50:46 +0000

With the rising popularity of single page applications, mobile applications, and RESTful API services, the way web developers write back-end code has changed significantly. We now use expresswebjs to build APIs that our front-end applications consume. ExpressWebJs strives to give you the tools you need to implement authentication quickly, securely, and easily. Since ExpressWebJs does not support session state, incoming requests that you wish to authenticate will be authenticated via a stateless mechanism such as API tokens.

In this article, we will look at using JWT to secure our ExpressWebJs APIs.

What is a JSON Web Token?

JSON Web Token (JWT) is an open standard that allows two parties to securely send data and information as JSON objects. This information can be verified and trusted because it is digitally signed.

JWT authentication has aided the wider adoption of stateless API services. It makes it convenient to authorise and verify clients accessing API resources. It is a critical part of the authentication system in javascript powered applications.

Getting Started

The first thing we are going to do is create a new expresswebjs application.To start your new project, you can open your terminal or CLI and type npx expresswebcli new command, followed by your project name. Example:

  npx expresswebcli new jwtApp

Once that is done, cd into your project like so cd jwtApp and run npm install to install your packages.

When that is done, you can now create your .env file:

   cp example.env .env

In our .env we can now configure our database. ExpressWebJs supports SQL and NOSQL database. In this tutorial, we will be using Mysql which is an SQL database.

APP_KEY=base64:Mk9TtGvMu3Kfp9wdahuownbdgsI3VTx2MXTQjN/6CFBadI=
APP_NAME=ExpressWebJs
APP_ENV=local
APP_HOST=127.0.0.1
APP_PORT=5000
APP_TRANSFER_PROTOCOL=http

DB_SHOULD_CONNECT=true
DB_CONNECTION=mysql
DB_HOST=localhost
DB_PORT=3306
DB_USER=
DB_PASSWORD=
DB_DATABASE=network-provider
DB_USENEWURLPARSER=true
DB_USEUNIFIEDTOPOLOGY=true
DB_USECREATEINDEX=true

Note: Don't forget to set your APP_KEY.

run npm run dev to start your app

To generate our authentication files, we will now run auth Maker command to setup our auth routes

  node maker make-auth

Our auth routes will be generated in Routes/authRoute/index.js file.

"use strict";
const Route = require("@routerManager");

/*
|-------------------------------------------------------------
| Authentication Route File   
|-------------------------------------------------------------
|
| This route handles both login and registration.
| 
*/

Route.post("/register", "Auth/RegisterController@register");

Route.post("/login", "Auth/LoginController@login");

module.exports = Route.exec;

Next, uncomment the auth middleware inside the App/Http/kernel.js file routeMiddleware section:

  /*
  |-----------------------------------------------------------
  | Route Middleware
  |-----------------------------------------------------------
  |
  | Route middleware is a key/value object to conditionally 
  | add middleware on
  | specific routes or assigned to group of routes.
  |
  */
  routeMiddleware: {
    auth: "App/Http/Middleware/Auth",
  },

At this point we need to setup and run our migration schema for our user model. Head over to Database/Migrations/20201209124747_user.js file.

/**
 * Migration layout file.
 * Assign your table name to the tableName variable.
 * Remember, it's always in plural
 */
let tableName = "users";
exports.up = function (knex) {
  return knex.schema.createTable(tableName, (table) => {
    table.increments("id");
    table.string("username").notNullable();
    table.string("email").unique().notNullable();
    table.string("password", 255).notNullable();
    table.timestamps(true, true);
  });
};

exports.down = function (knex) {
  return knex.schema.dropTable(tableName);
};

we can now run our migration with the following command:

   node maker run-sql-migration

To view our authentication config, head over to App/Config/auth.js file.

  module.exports = {
  /*
  |-----------------------------------------------------------
  | Authenticator
  |-----------------------------------------------------------
  |
  | ExpressWebJs does not support session state, incoming 
  | requests that 
  | you wish to authenticate must be authenticated via a 
  | stateless mechanism such as API tokens.
  |
  */
  authenticator: "jwt",

  /*
  |-----------------------------------------------------------
  | Jwt
  |-----------------------------------------------------------
  |
  | The jwt authenticator works by passing a jwt token on each 
  | HTTP request
  | via HTTP `Authorization` header.
  |
  */
  jwt: {
    model: "User_model",
    driver: "jwt",
    uid: "email",
    password: "password",
    secret: process.env.APP_KEY,
    options: {
      expiresIn: 86400, //default is 86400 (24 hrs)
    },
  },
};

To read more about authentication config, visit ExpressWebJs Authentication.

Route Authentication

We can now authenticate our routes like so:

  Route.get('/user', 'UserController@index',['auth']);

You can also authenticate your route groups like so:

  Route.group('/user',['auth'],()=>{
    Route.get('/', 'UserController@index');
    Route.get('/:id', 'UserController@show');
    Route.post('/save', 'UserController@save');
    Route.patch('/update', 'UserController@update');
    Route.delete('/delete', 'UserController@destroy');
});

READ developing-rest-apis-with-expresswebjs-v2.

In your PostMan, access the register endpoint using a post method 127.0.0.1:5000/api/register and input your username, email and password.

Conclusion

Well done! You have learned how to secure your API routes with ExpressWebjs. Need to use ExpressWebjs to build your API or micro-service? I'd bet on ExpressWebjs as the tool of choice for speed and ease of use.

I will be discussing on ExpressWebjs Data Validation in my next article.
You can follow me on twitter @EmekaIgbokwe
You can follow ExpressWebJs on twitter @expresswebjs
and don't forget to star on github ExpressWebJs

Please, let me know if you have any questions in the comment section. 😊

Documenting your ExpressWebJs API with Swagger

Chukwuemeka Igbokwe — Fri, 26 Feb 2021 14:23:34 +0000

Almost every application today has to be connected to share data with other applications. The best way to do that is through APIs and ExpressWebjs is the goto framework for building your node apis.

In this tutorial, however, we’re going to explore Swagger usage along with expressWebjs.

What is Swagger?
On the Swagger site we can find definition of Swagger:
Swagger is the world’s largest framework of API developer tools for the OpenAPI Specification(OAS), enabling development across the entire API lifecycle, from design and documentation, to test and deployment.

In our example, we’ll be making use of the two libraries: swagger-ui-express and swagger-jsdoc.

The first is a module that allows you to feed a Swagger UI (auto-generated views based on the swagger-ui project) from a swagger.json file, or from an inline object.

The second is about integrating Swagger using JSDoc comments in Docs directory in ExpressWebjs. This is pretty useful, especially when you have extensive APIs and dozens of models.

Application setup

Install ExpressWebJs

Run the following command in your terminal to create a new project with ExpressWebJs:

   npx expresswebcli new myNewApp

cd into your newly created project.

   cd myNewApp

Visit my article on developing rest apis with expresswebjs or expresswebjs documentation for work through on how to get started with expresswebjs.

Adding swagger

Now that our application is ready,

we can now integrate swagger by creating our swagger.json file in the root directory

{
    "definition": {
      "openapi": "3.0.n",
      "info": {
        "title": "My Website API Documentation",
        "version": "0.1.0",
        "description":
          "My website API docs with ExpressWebJs and documented with Swagger",
        "license": {
          "name": "MIT",
          "url": "https://spdx.org/licenses/MIT.html"
        },
        "contact": {
          "name": ""
        }
      },
      "servers": [
        {
          "url": "http://localhost:5100/api"
        }
      ]
    },
    "apis": ["./Docs/*.js"]
  }

This "apis": ["./Docs/*.js"] section specifies the path where your actual documentations are. In our case, it is in Docs folder in the root directory.

After that we can now create our swagger service in App/Service directory.

In App/Service directory, lets create a Swagger folder with an index.js file. Our path will be App/Service/Swagger/index.js

 //App/Service/Swagger/index.js
const swaggerJsdoc = require("swagger-jsdoc");
const swaggerUi = require("swagger-ui-express");
const options = require("../../../swagger.json");

class Swagger{
  static run(){
    let specs = swaggerJsdoc(options);
    serverApp.use("/api-docs",swaggerUi.serve,swaggerUi.setup(specs,{exporer:true}));
  }
}

module.exports = Swagger;

ExpressWebJs ServiceProvider

Next we will register our swagger service in our application service provider. Navigate to App/Providers/AppServiceProvider.js file and add our swagger service to be executed at boot time

 const swagger = require("../Service/swagger");

 class AppServiceProvider {
  /**
   * Register application services.
   */
  register() {
    return {
      //
    };
  }

  /**
   * Bootstrap any application services.
   *
   * @return void
   */
  boot() {
    swagger.run();
  }
}

module.exports = AppServiceProvider;

Note: you can create your own service provider. Read more about ExpressWebjs ServiceProvider in the Documentation site.

Once all the setup is done, you can now start writing your api documentation in the Docs directory.

To view your swagger docs, run your project using

  npm run dev

and navigate to http://127.0.0.1/api/api-docs in your browser.

Conclusion

Thank you for reading my article
You can follow me on twitter @EmekaIgbokwe
You can follow ExpressWebJs on twitter @expresswebjs
and don't forget to star on github ExpressWebJs

Please, let me know if you have any questions in the comment section. 😊

Developing REST APIs with ExpressWebJs v2(A Nodejs Framework) part 2.

Chukwuemeka Igbokwe — Thu, 18 Feb 2021 07:53:37 +0000

We discussed the following in our previous article on Developing REST APIs with ExpressWebJs v2(A Nodejs Framework) part 1.:

.Installing ExpressWebJs
.Database setup
.Creating models and migration
.Creating controllers
.Creating routes

In this article, we are going to focus on the business logic of our employee record.

Our newly created EmployeesController in App/Http/Controllers directory looks like so:

  "use strict";

        class EmployeesController{
          /**
           * Display a listing of the resource.
           */
          index = async (req, res, next) =>{
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Show the form for creating a new resource.
           *
           * @return Response
           */
          create = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Store a newly created resource in storage.
           * @param  Request 
           * @return Response
           */
          store = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Display the specified resource.
           * @param  Request
           * @return Response
           */
          show = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Show the form for editing the specified resource.
           * @param  Request
           * @return Response
           */
          edit = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Update the specified resource in storage.
           * @param  Request
           * @return Response
           */
          update = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Remove the specified resource from storage.
           *
           * @param Request
           * @return Response
           */
          destroy = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }
        }

        module.exports = EmployeesController;

Adding our model.

We can require our model into our controller like so:

const employeesModel = require("../../Model/Employees_model");

OR we can do:

const employeesModel = require("@model/Employees_model");

Now that we have our employeesModel in our EmployeesController, we can now start querying our database.

Getting all employees

const employeesModel = require("@model/Employees_model");

class EmployeesController{
  /**
   * Display a listing of the resource.
  */
  index = async (req, res, next) =>{
    try{
       let employees = await employeesModel.query();
       return res.status(200).json(employees);
    }catch (error) {
       return next(error);
      }
    }

Getting a particular employee

const employeesModel = require("@model/Employees_model");

class EmployeesController{
  /**
    * Display the specified resource.
    * @param  Request
    * @return Response
  */
  show = async (req, res, next) =>{
    try{
       let employee = await employeesModel.query()
                       .findById(req.params.id);
       if(employee){
         return res.status(200).json(employee);
       }
       return res.status(404).json({msg:'No record found'});
    }catch (error) {
       return next(error);
      }
    }

Saving employee record

const employeesModel = require("@model/Employees_model");

class EmployeesController{
  /**
    * Store a newly created resource in storage.
    * @param  Request 
    * @return Response
   */
  store = async (req, res, next) =>{
    try{
       let employee = await employeesModel.query()
                       .insert(req.body);
       if(employee){
         return res.status(200).json(employee);
       }
       return res.status(404).json({msg:'No record found'});
    }catch (error) {
       return next(error);
      }
    }

Note!: we didn't validate our data before saving to storage. Data validation in ExpressWebJs will be discussed in my next article. You can also read it up from the documentation site at ExpressWebJs Data Validation

Updating employee record

const employeesModel = require("@model/Employees_model");

class EmployeesController{
  /**
    * Update the specified resource in storage.
    * @param  Request 
    * @return Response
   */
  update = async (req, res, next) =>{
    try{
       let employee = await employeesModel.query()
                       .findById(req.params.id)
                       .update(req.body);
       if(employee){
         return res.status(200).json(employee);
       }
       return res.status(404).json({msg:'No record found'});
    }catch (error) {
       return next(error);
      }
    }

We can also do

let employee = await employeesModel.query()
                       .where('id','=',req.params.id)
                       .update(req.body);

Deleting an employee

const employeesModel = require("@model/Employees_model");

class EmployeesController{
  /**
    * Remove the specified resource in storage.
    * @param  Request 
    * @return Response
   */
  destroy = async (req, res, next) =>{
    try{
       let employee = await employeesModel.query()
                       .findById(req.params.id)
                       .delete(req.body);
       if(employee){
         return res.status(200).json(
          {msg:'Employee successfully removed'}
         );
       }
       return res.status(404).json({msg:'No record found'});
    }catch (error) {
       return next(error);
      }
    }

We can also do

let employee = await employeesModel.query()
                       .deleteById(req.params.id);

Conclusion

Well done! You have learned how to build a rest API with ExpressWebjs. Need to use ExpressWebjs to build your API or micro-service? I'd bet on ExpressWebjs as the tool of choice for speed and ease of use.

I will be discussing on ExpressWebjs Authentication and ExpressWebjs Data Validation in my next article.
You can follow me on twitter @EmekaIgbokwe
You can follow ExpressWebJs on twitter @expresswebjs
and don't forget to star on github ExpressWebJs

Please, let me know if you have any questions in the comment section. 😊

Developing REST APIs with ExpressWebJs v2(A Nodejs Framework) part 1.

Chukwuemeka Igbokwe — Wed, 17 Feb 2021 22:21:34 +0000

ExpressWebJs is a Node FrameWork with expressive and organised syntax that runs on all major operating systems. It provides the starting point for creating your node project, allowing you to focus more on developing your amazing solution.

ExpressWebJs focuses on providing developer experience and powerful features such as dependency injection,database abstraction layer for both SQL and NOSQL, robust routing, code structure, application configuration, testing and more.

There are some built in features of ExpressWebJs

. Robust routing
. Focus on high performance
. Super-high test coverage
. HTTP helpers (redirection, caching, etc)
. Support for both SQL and NOSQL database
. Well organised and structured.
. Supports Use Of Dependency Injection
. Supports websocket
. Highly scalable
. Events and Listeners
. Queues
. Task Scheduling

Building an employee record API with ExpressWebJs

At company X, we have many employees. We are asked to build an app to manage our employee record. The front end app will be built with Vuejs or ReactJs. However, it needs to pull data from a source and also push to it. We need an API which we are going to develop with ExpressWebJs.

This is what we need our API to do:
. Get all employees
. Get an employee
. Add new employee
. Edit employee record
. Delete an employee

For the endpoints, we will be looking at:
. GET /api/employees
. GET /api/employees/6
. POST /api/employees
. PATCH /api/employees/6
. DELETE /api/employees/6

Next we will look at employees attribute:
. name
. email
. phone
. location
. country
. state

Install ExpressWebJs

Run the following command in your terminal to create a new project with ExpressWebJs:

  npx expresswebcli new employeesApp

cd into your newly created project.

  cd employeesApp

Now run npm install to install all dependencies.

Copy example.env into .env file with the following command

 cp example.env .env

Once that is done, you can now configure your database in the .env file.

Remember: ExpressWebJs supports Both SQL and NOSQL Database.

For this tutorial, we will be working with mysql db (sql database).

Now, run npm run dev to serve the project. Head over to your browser.

Migration:

ExpressWebJs comes with Maker command, which is the command line interface. Maker exists at the root of your application as the maker script and provides a number of helpful commands that can assist you while you build your application. To view a list of all available Maker commands, you may use the help command:

  node maker -h

So for us to create our employees migration and model, we can do that like so:

  node maker make-sql-model employees -m

-m tells Maker to also generate out migration while creating our model.

The new migration will be placed in Database/Migrations .
Each migration file name contains a timestamp, which allows ExpressWebJs to determine the order of the migrations. Next, we'll modify the recently created migration to include the attributes we need for the employees table.

Open up the migration file and modify it like so:

  /**
   * Migration layout file.
   * Assign your table name to the tableName variable.
   * Remember, it's always in plural
  */
  let tableName = "employees";
  exports.up = function (knex) {
  return knex.schema.createTable(tableName, (table) => {
    table.increments("id");
    table.string("name").notNullable();
    table.string("email").unique().notNullable();
    table.string("phone").notNullable();
    table.string("location").notNullable();
    table.string("country").notNullable();
    table.string("state").notNullable();
    table.timestamps(true, true);
  });
};

exports.down = function (knex) {
  return knex.schema.dropTable(tableName);
};

Now, go ahead and run the migration like so:

   node maker run-sql-migration

Check your database. You should now have the employees and migrations tables present.

model

when we ran the node maker make-sql-model employees -m ExpressWebjs generated our model in the App/Model directory.

App/Model/Employees_model.js

   "use strict";
   const Model = require("@elucidate/Model");
   class Employees extends Model {
      static get tableName() {
         return "employees";
      }
   }

   module.exports = Employees;

Set up Employees Controller

To create a new controller called EmployeesController, use the maker command for controller:

  node maker make-controller EmployeesController -r

where -r will tell Maker to generate our controller with resource methods.

Our Controller will be generated in App/Http/Controller directory

App/Http/Controller/EmployeesController:

  "use strict";

        class EmployeesController{
          /**
           * Display a listing of the resource.
           */
          index = async (req, res, next) =>{
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Show the form for creating a new resource.
           *
           * @return Response
           */
          create = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Store a newly created resource in storage.
           * @param  Request 
           * @return Response
           */
          store = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Display the specified resource.
           * @param  Request
           * @return Response
           */
          show = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Show the form for editing the specified resource.
           * @param  Request
           * @return Response
           */
          edit = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Update the specified resource in storage.
           * @param  Request
           * @return Response
           */
          update = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }

          /**
           * Remove the specified resource from storage.
           *
           * @param Request
           * @return Response
           */
          destroy = async (req, res, next) => {
            try{
              //
            }catch (error) {
              return next(error);
            }
          }
        }

        module.exports = EmployeesController;

We will fill up our EmployeesController in a bit.

Set up Routes

Routing is fairly straight-forward. Open up Routes/api.js and modify it like so:

   "use strict";
   const Route = require("@routerManager");
   /*
    |---------------------------------------------------------
    | Api route   
    |---------------------------------------------------------
    |
    | Here is where you can register your application routes. 
    | These
    | routes are loaded by the RouteProvider. Now create 
    | something great!
    |
  */

Route.get("/", (req, res) => {
  res.json({ Message: "Welcome To ExpressWebjs" });
});

Route.group("/employees", () => {
  Route.get("/","EmployeesController@index");

  Route.get("/:id", "EmployeesController@show");

  Route.post("/", "EmployeesController@store");

  Route.patch("/", "EmployeesController@update");

  Route.delete("/:id", "EmployeesController@destroy");
});

module.exports = Route.exec;

We will start developing the business logic in part 2.

To read more about ExpressWebJs, visit the Documentation site at ExpressWebJs

You can follow me on twitter @EmekaIgbokwe
You can follow ExpressWebJs on twitter @expresswebjs
and don't forget to star on github ExpressWebJs

Please, let me know if you have any questions in the comment section. 😊

Expresswebjs a node framework for node devs

Chukwuemeka Igbokwe — Sun, 25 Oct 2020 18:29:14 +0000

Today we are proud to announce the official release of Expresswebjs. This new major version of the framework provides a lot of features and improved performance. Visit the official website expresswebjs.com for full documentation and use.