DEV Community: NotFound404

The reasons why node.js can't be a new dominance in backend development

NotFound404 — Tue, 10 Sep 2024 16:26:08 +0000

Npm conducted a very wrong version illusion: Semver, assuming that libraries can always deliver a correct version obey Semver's rules.
Npm then add the ability to auto update so called version range without any test and check up, which totally ruined the stability for a node project and consistency. Now, the node ecosystem is still a mess and only played by the frontend ecosystem which needs almost no stability and consistency.
Advocate green keeper to force all packages to updated which eventually exhausts developers.
Node.js has no good backend frameworks. express is very simple, sails is very slow, koa is very wrong and aex comes up very late.

Also npm added package lock trying to keep the packages stable, but the timing can never be back again and some developers have leave the node.js community for not able to see the future improvement.

Best node.js web frameworks you must know in 2024

NotFound404 — Sat, 09 Mar 2024 12:34:29 +0000

1. express.js

This framework is the most popular one since node.js was created.
It's ecosystem is very mature, but due to lack of updates on new javascript features, it is somewhat behind the time.
And it's code is somewhat too cohesive to be well modulised and updated in time.

2. sails.js

sails.js is based on express and extended to be the best mvc web framework ever created for node.js,
It is specifically well fit for small business sites.
It has many features modern web frameworks which can help you rapidly develop your sites.
Due to its complexity and ambition, it is somewhat immature for more use cases.
And is not very performant and also somewhat too cohesive to be well modulised and separated when needed.

3. aex.js

aex was originally developed to make sails' modules optional,
and aware that mvc is not suitable for web frameworks.
So it is backed with a new theory - the Web Straight Line Theory and claim that mvc is not suitable for the web frameworks.

Over time when the typescript is emerged and async/await is introduced, aex was totally rewrited to embrace async/await features and fully utilize the Web Straight Line Theory.

The Web Straight Line theory aside, it also incorporated express's middleware and necessary concepts for web frameworks from sailsjs.

Aex is well modulised and very extensible. It is compatible with most express's middleware and support new features of javascript/typescript specifically async/await and decorators.
It is spring like when decorator is used, but more suitable for web development with the Web Straight Line theory backed instead of MVC theory.

Its core apis are very stable since its creation.
Aex is relatively new and has a very small community, so you should use it at your risk.

除夕快乐，新年大吉！Happy Chinese New Year!

NotFound404 — Fri, 09 Feb 2024 12:39:06 +0000

Happy Chinese New Year!

Why wrong/useless concepts are spreading recklessly and widely nowadays?

NotFound404 — Tue, 30 Jan 2024 07:25:50 +0000

We all know that computer science is rooted from math aim to accelerate the speed of calculation.
It is based on precise rules and correct logic.
But when time goes on, computers are capable of doing more things than just calculation.
It problems of human become the problems of the programs.
Humans do wrong things, the programs specifically famous libraries and frameworks too.
For example, blockchains is bound with decentralization while blockchains are only the verification of a serials block data. While decentralization is only a negotiation policy between servers.
Mixing frontend with backend in wrong way to claim them a fullstack framework while they even don't know what the backend framework should be like(I can say that 90% web application frameworks are wrongly designed), for example next.js, nest.js, metoer.
Some frameworks even don't understand the difference between middlewares and stacks(for example the wrong mixing usage with middlewares, callbacks and stacks in koa)
Some advocators claim nosql can totally replace relational db, and time have now taught them a lesson.
There was ever a time that someone advocates that xml would take over html, and until html5 the trend was ended.
In node.js there was an insane green keeper policy to push developer's keep their package updated and with a very fascist version policy called semver.

I was ever thinking that big company developers are smaller than most of us, but now I think other way.
Sometimes they are only advocators of their products regardless of correctness.

This things may never stop from emerging, but people should be more critic when a new thing arises and claims it to be something.

双重验证就是智障验证

NotFound404 — Mon, 29 Jan 2024 08:22:41 +0000

世界上最愚昧的发明

Simplify your event messaging between Objects with Aex

NotFound404 — Mon, 13 Nov 2023 12:58:07 +0000

Event Messaging decorators

Aex can route messages between objects within an Aex instance.
You only need to prefix an member function with @listen and pass a event name to it， then you are listening to the event from all aex inner http handling class now.

A simple example is like the following:

class Listen {
  private name: string;
  constructor(name?: string) {
    this.name = name || "";
  }
  @listen("echo")
  public echo(emitter: EventEmitter, ...messages: any[]) {
    emitter.emit("echoed", messages[0]);
  }

  @get("/")
  public async get(_req: any, res: any, scope: Scope) {
    scope.emitter.on("echoed1", (mesasge) => {
      res.end(mesasge + " from " + this.name);
    });
    scope.emitter.emit("echo1", "Hello");
  }
}

class Listen1 {
  @listen("echo1")
  public echo1(emitter: EventEmitter, ...messages: any[]) {
    emitter.emit("echoed1", "echoed1 " + messages[0]);
  }
}

const emitter = new EventEmitter();
const aex = new Aex(emitter);
let port: number = 0;

aex.push(Listen, "Nude");
aex.push(Listen1);
aex.prepare().start();

This example shows that

The Listen class listens to an event called echo, within this handler, it sends a new event called echoed;if you listen to this event with the emitter, you will have notification for this event.
The Listen class also can handle http request to url /, it then emit echo1 event which will invoke Listen1's listener after Listen1 pushed to the same Aex object.
The Listen1 class listens to an event called echo1, within this handler, it emits a new event called echoed1; if you listen to this event with the emitter, you will have notification for this event.

if we only need to send messages between objects,
just use emitter to send messages:

emitter.emit("echo", "Hello Aex!");

emitter is an Buildin object from node.

Aex only simplifies this usage between classes, the behavior is not changed, you can refer node's EventEmitter for further information.

Event listeners of a class should not be http handlers of the class,
because they process different things.

The most stupid security method 2FA

NotFound404 — Fri, 27 Oct 2023 17:38:35 +0000

2FA only make the real owner lose their account!
Most stupid security method ever.

Simplify your API development with Aex

NotFound404 — Wed, 25 Oct 2023 08:30:25 +0000

Aex API Development Support

Aex currently support restful api and vig api

Restful API for resources state representation
Vig API for Business logic manipuliation

the usage similar with decorator @rest and @api.
Which means @api is a recommendded api for most applications which is suitable for business logic.

@rest

@rest decorator can help directing every request into a certain method according to its http method and with default body parser.

It is very simple to use just like other aex handlers:

class Rest {
  public async get(ctx: any) {}
  public async post(ctx: any) {}
  public async put(ctx: any) {}
  public async patch(ctx: any) {}
  public async delete(ctx: any) {}
  @rest("/rest/api")
  public api(ctx: any) {
    ctx.res.end("Rest API !");
  }
}

currently only five http methods(get, post, put, patch, delete) are allowed.

@api

@api decorator only supports get, post http methods. get is used for information fetch with changing anything, post is used for any business action may potantially change something.

the usage is very similiar except the http post request is force to have a field called action, which is the business action.
Actions can be any string and you should write corresponding method to handle that action. (Actions are case sensitive.)

for example, we need to write an api for user, we can define an api with @api like the following:

class UserAPI {
  public async register(ctx) {}
  public async login(ctx) {}
  public async logout(ctx) {}
  public async remove(ctx) {}
  public async update(ctx) {}

  @api("/user")
  public api(ctx: any) {
    ctx.res.end("VIG API");
  }
}

by sending action, the decorator will automatic route your request into corresponding method.

Further infomation and update about vig api can be found here:
https://github.com/calidion/vig-api

these decorators will be enhance overtime, and you can file a feature request any time.

basic aex usage can be found in README file:
https://github.com/calidion/aex

Three steps to start your restful api server with aex

NotFound404 — Tue, 24 Oct 2023 09:01:05 +0000

Aex is a web framework focus on productivity. With Aex, you can do more with less code.
if you want to write restful api, you normally would always do some dirty initialization works.
now aex provides a way to make restful api development a little more painless with node.js.
Here is how.

1. Restful API Class with @rest decorator to one of it's member functions.

import {rest} from "@aex/core"
class UserAPI {
@rest("/users")
 public road(ctx: any) {
 // this function default used for get method if you don't define a get method.
 }

2. Add corresponding methods

Currently aex supports "get", "put", "post", "patch", "delete", these five methods. all this methods should be async and default to compact mode.

import {rest} from "@aex/core"
class UserAPI {
@rest("/users")
public road(ctx: any) {
}
public async post(ctx:any) {
}

3. start aex server

import {Aex} from "@aex/core"
const aex = new Aex();
aex.push(UserAPI);
aex.prepare().start(8080).then(() => {});

For detailed usage or update, please visit the aex repo:
https://github.com/calidion/aex

Simplest way to use prisma with Aex

NotFound404 — Sun, 22 Oct 2023 11:26:23 +0000

Prisma is the best orm tool for node.js so far.
And aex is the best web framework for node.js and typescript so far.
With Aex and Prisma, You can boost your application development speed with less code.
Here is a simple way to show you how easy it is to create a web server with aex and prisma.

1. Create a class with http request handler(s)

class HelloAex {
  @compact("/")
  public async hello(ctx:any) {
    const {
      prisma,
    }: {
      prisma: PrismaClient;
    } = ctx.scope.orm;
    const users = prisma.user.findMany({});
    ctx.res.json(users);
    return;
  }
}

2. Create a prisma client and it's middleware for aex


const prisma = new PrismaClient();
const prismaMiddleware = (function (prismaClient) {
  return async (_, __, scope) => {
    await prismaClient.$connect();
    scope.orm = {};  // @aex/core v0.18.4+ has built-in orm property.
    scope.orm.prisma = prismaClient;
  }
})(prisma);

3. Create Aex and start the server

const aex = new Aex();
let port = 8081;

// add prisma support
aex.use(prismaMiddleware);
// init http handlers
aex.push(HelloAex);


// start aex server
aex
  .prepare()
  .start(port)
  .then(() => {
    console.log("Server started at http://localhost:" + port + "/");
  })
  .finally(async () => {
    // disconnect prisma when server is closed.
    await prisma.$disconnect();
  });

4. Run the server with ts-node.

Save all the above code into a file we can name it server.ts， then we can run it with the following command.

npx ts-node server.ts

then we can have the following output:

Server started at http://localhost:8081/

5. github code

The above code needs some initial work, you can just download code from https://github.com/aex-ts-node/primsa-example
then run the following code:

git clone https://github.com/aex-ts-node/primsa-example
cd primsa-example/
npm i
npx prisma generate
npx ts-node server.ts

You can now boot an aex server with prisma backed.

Function Parameter Mode Choices for Http Handlers

NotFound404 — Wed, 04 Oct 2023 12:21:06 +0000

Function Parameter Mode Choices for Http Handlers

The Classic Mode

Classically, the node original library handles HTTP requests with a request and response separately.
For async's sake, node also provide a callback to further processing the request. That is to say, node has the original http handler calllback function parameter mode like this.

function classicHTTPHandler(req, res, next)

We can call this mode the classic mode.
This mode is a very basic parameter passing method, it can only passes the request, the response and the callback function when async is not promised.

It has at least two weakness:

Not promise-based, not friendly with async/await functions.
Don't have a proper place to carry generated data by middlewares when going through the Web Straight Line.

The Onoin Mode (The Wrong Mode)

On solve problem one, someone created a wrong mode: The Onoin Mode. Which turns lined lists with stacks. Its function parameter mode looks like this.

async function onoinHTTPHandler(req, res, next)

It enabled promise and incorrectly kept the callback function next.

And we can call this mode the onoin mode.

As this project point out, the web processing patthen is called the web straight line. It goes every phrase one by one orderly and sequentially, not like a stack.

This causes rewriting of every middleware ever created originally supporting the classic mode.

It is obvious a waste of effort and discouragment for developers to maintain two copy middlewares for one purpose.
Fortunately this wrong mode never dominates.

By the time of this writing, this mode is still relatively small due to it's incorrectness.

The promise based mode / the aex mode

The correct way to asynchronize the classic mode is to remove the next callback. And in order to fixed weakness two, we can introduce a new parameter for data carriage. In aex, it introduces the function parameter mode like this.

async function  aexHTTPHandler(req, res, scope) {
  res.end()
  scope.body
  scope.inner
}

Which we can call it the promis based mode or the aex mode, first introduced by the aex web framework project.

But this mode is still some time inconvient when you don't have to use request , response.

So to compact them into one variable may be more efficiently, then we have the compatc mode.

The Compact Mode

The compact mode is an optimization for some cases when you don't use the parameters in an ordered way. For example, you are writing a middleware only needs to process the scoped data. You don't need request, response to show up at all. then you can use this mode. Its function parameter mode looks like this.

async function  compactHTTPHandler(ctx) {
  // ctx.request
  // ctx.response
  ctx.scope
}

So you can ignore the req, res parameters with compact mode when necessary.

All the three correct modes are supported by aex. The compact mode and the promise-based mode/ the aex mode are the recommended modes in aex.

You can refer here for how to use them when best suit your needs.

Using Compact Mode with Aex v0.18.0

NotFound404 — Sat, 30 Sep 2023 13:00:02 +0000

Traditionally we handle http request with a callback have parameters named:
request, response, next or something.
In Aex, we use :

req, res, scope

where scope is a data carrier for the request.

The following is the traditional http handler in aex:

class User {
@http("get", "/user/login")
public async login(req, res, scope) {
}
}

in aex v0.18.0, we introduced the compact mode, where we can use only one variable if others are not needed.

Here is the compact mode http handler in aex:

class User {
@http("get", "/user/login", true)
public async login(context) {
  const {req, res, scope} = context;
  const res = context.res;
}

@compact("get", "/user/login")
public async compact(context) {
  const {req, res, scope} = context;
  const res = context.res;
}
}

It wraps all variables into one context object.

So you can choose a tidy one for your programs for certain development stages.

You can start with compact mode then to the traditional mode or traditional mode to compact mode.

You can try it with :

npm install github:calidion/aex#v0.18.0