thesoftwarehouse / express-boilerplate Goto Github PK

Boilerplate for setting up express.js applications

License: MIT License

TypeScript 70.15% Dockerfile 1.52% Shell 3.51% JavaScript 24.82%

express-boilerplate's Introduction

Current travis build:

A highly scalable and a focus on performance and best practices boilerplate code for Nodejs and TypeScript based web applications.

Start a new application in seconds!

Features

Quick scaffolding

Create actions, routes, and models - right from the CLI using Plop micro-generator framework.
TypeScript

The best way to write modern applications. Code is easier to understand. It is now way more difficult to write invalid code as was the case in dynamically typed languages
Dependency injection

DI is a central part of any nontrivial application today and is the core of this project.
Static code analysis

Focus on writing code, not formatting! Code formatter and linter keeps the code clean which makes work and communication with other developers more effective!

Note If you have discovered a bug or have a feature suggestion, feel free to create an issue on Github.

Don't forget to star or fork this if you liked it.

Configuration

After checkout of a repository, please perform the following steps in exact sequence:

Copy docker-compose.override

$ cp docker-compose.override.yml.dist docker-compose.override.yml

Create .env file from .env.dist
```
$ cp .env.dist .env
```
Remember to fill up required values in .env
Run npm i
Run npm run docker-build
Run watch - npm run watch

Dev setup

This app is fully dockerized, so in order to use it you have to have docker and docker-compose installed. What's more you need to have npm in order to run npm scripts.

In order to run the whole app type:
```
npm run start
```
In order to watch files for dev purpose type:
```
npm run watch
```
If you need to close all containers run:
```
npm run down
```
To get into Docker container's shell:
```
npm run shell
```

SonarQube configuration

Before deployment, please ensure that a related SonarQube project has been created. After that set proper repository variables (SONAR_TOKEN and SONAR_HOST_URL) and properties in sonar-project.properties file.

Code generation

We're using Plop for routes, models, actions, graphql (queries and mutations), commands and handlers generation.

npm run plop

Code style

We're using Prettier and ESLint to keep code clean. In order to reformat/check code run:

npm run lint
npm run format

Database migrations

Migrations should be stored inside migrations directory.

Easiest way to create a migration is to generate it from entity/ies:

npm run generate-migration

This should generate a migration for all connected entities.

Adminer setup

Adminer is configured in docker-compose.override.yml and should work out of the box on port 8080. To login to adminer use the following values:

Database type: postgres
Server: postgres
User: postgres
Password: password
Database: app

Of course, if any of this is changed via configuration or otherwise, then these changes must be reflected here as well.

GraphQL

Boilerplate has GraphQL support. Apollo server runs as a middleware and should be available locally under:

http://localhost:1337/graphql

To add new query/mutation run relevant plop commands and then:

Modify schema.gql under graphql/schema.gql
Run codegen: npm run generate-schema
Restart watcher / API

Debugging

VS Code

There is launch.json configuration inside editors/vsc directory. Just copy it and create new debugger to make it work with vsc :)

Tests

There are two types of tests:

integration: npm run integration
units: npm run units

Issues:

If you notice any issues while using, let as know on github. Security issues, please sent on email

About us:

The Software House

License

This project is licensed under the terms of the MIT license.

express-boilerplate's People

Contributors

Stargazers

Watchers

express-boilerplate's Issues

Move users to samples

Code in features/users isn't part of framework. Shouldn't be removed or moved to samples/examples?

Consider introducing new rule "force-return-await` to achieve better stack traces

Reason
In node.js 10 the result of code below will be different than in node 8.

const sleep = delay => new Promise(resolve => setTimeout(resolve, delay));
const test1 = async (a = 0) => {
    await sleep(10);
    if(a < 10) return test1(a+1);
    else console.trace('noawait', a);
};
test1();
const test2 = async (a = 0) => {
    await sleep(10);
    if(a < 10) return await test2(a+1);
    else console.trace('await', a);
};
test2();

Description
We should consider adding a custom rule which will force return await in functions.
However it isnt well optimized in node.js 12.

returnAwait: 1301.600ms
noReturnAwait: 1158.415ms

We should check how newer versions of node optimize it.

@CacheQuery decorator doesn't support nested queries

What is the issue?

As the issue's title states, there is a problem with nested queries for @CacheQuery decorator

Current behaviour

Let's assume that we have a query handler as described below:

export default class UsersQueryHandler implements QueryHandler<UsersQuery, UsersQueryResult> {
  public queryType: string = USERS_QUERY_TYPE;

  @CacheQuery({ duration: 60 })
  async execute(usersQuery: UsersQuery): Promise<UsersQueryResult> {
    return new UsersQueryResult({
      randomNumber: Math.random(),
    });
  }
}

our UsersQuery class looks like this:

export const USERS_QUERY_TYPE = "example/USERS";

export interface UsersQueryPayload {
  name?: string;
  surname?: string;
}

export class UsersQuery implements Query<UsersQueryPayload> {
  public type: string = USERS_QUERY_TYPE;

  constructor(public payload: UsersQueryPayload) {}
}

Now let's imagine that we are making query as stated below:

GET /api/example/example?name=bart&surname=baz

in such case, @CacheQuery decorator will construct a cache key for this query as given below:

Queries:UsersQueryHandler:[object Object]_example/USERS

That is the problem because the second query with different query params will be saved under the same cache key as the previous one (please note [object Object]).

Expected behaviour:

Different queries should be cached under different cache keys

Possible solution

I would suggest stringifying the queries so nested query objects will be saved under proper keys instead of [objet Object]

For example, if we would like to use JSON.stringify for stringifying the keys, then a cache key for given above query would look like this:

Queries:UsersQueryHandler:payload={"query":{"name":"bart","surname":"baz"}}_type="example/USERS"

Please see the attached PR for more details.

Node Prune does not work in new Macbook with M1 pro chip

executor failed running [/bin/sh -c apk add --no-cache bash curl git py-pip make && curl -sfL https://install.goreleaser.com/github.com/tj/node-prune.sh | sh && npm install node-dev -g && npm cache clean --force]: exit code: 1

This was the error I was getting. I changed the dockerfile to this

RUN apk add --no-cache bash curl git py-pip make &&
npm install node-dev -g && npm cache clean --force

RUN apk --no-cache add curl bash
RUN npx node-prune

to make it work