Commit comitted

Author: Ta0uf19

.gitignore

@@ -0,0 +1,2 @@
+node_modules/*
+.idea/*

Entry.ts

@@ -0,0 +1,26 @@
+import {App} from "./app/App";
+
+const port: number = 3000;
+new App().start().then((server) => {
+    server.listen(port);
+    server.on("error", (error: any) => {
+        if (error.syscall !== "listen") {
+            throw error;
+        }
+        switch (error.code) {
+            case "EACCES":
+                console.error("Port requires elevated privileges");
+                process.exit(1);
+                break;
+            case "EADDRINUSE":
+                console.error("Port is already in use");
+                process.exit(1);
+                break;
+            default:
+                throw error;
+        }
+    });
+    server.on("listening", () => {
+        console.log("Server is running in process " + process.pid + " listening on PORT " + port + "\n");
+    });
+});

README.md

@@ -0,0 +1,37 @@
+#Starter template Rest
+#### TypeScript + TypeOrm + ExpressJS + Validator Middleware
+## Structure
+```
+/app
+	/controllers (Controllers of the app)
+	/core (Core of starter template)
+	/middlewares (Middlewares for the routes of the app)
+	/routes (Routes for Controllers of the app)
+	/models (Models configuration for use)
+	/repository (Custom queries)
+	/App.ts (Server configuration)
+	/Router.ts (Config file for Routing)
+
+config.ts (Config file for the app)
+tsconfig.json (File configuration typescript)
+tslint.json (File configuration rules typescript)
+Entry.ts (Main file to start the app)
+```
+
+## Usage
+In Development mode, the express app is started with nodemon for automatic refresh when changes are made.
+````
+npm run dev
+````
+## Todo
+- [X] TypeORM
+- [X] Validator Middleware
+- [ ] Configuration file
+- [ ] Swagger Docs
+- [ ] Release bundle
+- [ ] JWT Middleware
+- [ ] Dockerfile
+
+## License
+Usage is provided under the MIT License. See LICENSE for the full details. \
+Copyright © 2020, Taoufik Tribki

app/App.ts

@@ -0,0 +1,87 @@
+/**
+ *  @Ta0uf19
+ *  Server application class
+ */
+
+import * as express from "express";
+import * as http from "http"
+import * as logger from "morgan"
+import {createConnection, Connection} from "typeorm";
+import {Router} from "./Router";
+
+export class App {
+
+    private readonly app: express.Application;
+    private readonly server: http.Server;
+
+    constructor() {
+        this.app = express();
+        this.server = http.createServer(this.app);
+    }
+
+    /**
+     * Start server
+     */
+    public async start(): Promise<http.Server> {
+        this.configureExpress();
+        this.configureRouter();
+
+        // start connection
+        await App.getConnection();
+        return this.server;
+    }
+
+    /**
+     * Get application instance
+     */
+    get App(): express.Application {
+        return this.app;
+    }
+
+    /**
+     * Configure connection to database
+     */
+    private static async getConnection(): Promise<Connection> {
+        const connection: Connection = await createConnection({
+            type: "mongodb",
+            host: "localhost",
+            port: 27017,
+            database: "express",
+            entities: [
+                "./app/models/*.ts"
+            ],
+        });
+        return connection;
+    }
+
+    /**
+     * Config express middlewares
+     */
+    private configureExpress(): void {
+        this.app.use(logger('dev'));
+        this.app.use(express.json());
+        this.app.use(express.urlencoded({ extended: false }));
+        this.app.use((req, res, next): void => {
+            res.header("Access-Control-Allow-Origin", "*");
+            res.header("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Authorization");
+            res.header("Access-Control-Allow-Methods", "GET,PUT,PATCH,POST,DELETE,OPTIONS");
+            next();
+        });
+        //this.app.use(cookieParser());
+    }
+
+    private configureRouter(): void {
+        for(let route of Router) {
+            this.app.use(route.path, route.middleware, route.router)
+        }
+
+        this.app.use((req: express.Request, res: express.Response, next: express.NextFunction): void => {
+            res.status(404);
+            res.json({
+                error: "Not found",
+            });
+            next();
+        });
+
+    }
+}

app/Router.ts

@@ -0,0 +1,16 @@
+import * as express from "express";
+import { GarantieRouter } from "./routes/GarantieRouter";
+
+interface IRouter {
+    path: string;
+    middleware: any[];
+    router: express.Router;
+}
+
+export const Router: IRouter[] = [
+    {
+        path: "/api/garantie",
+        middleware: [],
+        router: (new GarantieRouter()).router,
+    }
+];

app/controllers/GarantieController.ts

@@ -0,0 +1,73 @@
+import {Controller} from "../core/Controller";
+import { Request, Response } from "express";
+import {Repository, getConnection, ObjectID} from "typeorm";
+import {Garantie} from "../models/Garantie";
+import {validate, ValidationError} from 'class-validator';
+import {plainToClass} from "class-transformer";
+
+export class GarantieController extends Controller {
+
+    private garantieRepository : Repository<Garantie>;
+
+    constructor(req: Request, res: Response) {
+        super(req, res);
+        this.garantieRepository = getConnection().getRepository(Garantie);
+    }
+
+    public async all(): Promise<Response> {
+        const list = await this.garantieRepository.find();
+        return this.res.send(list);
+    }
+
+    public async find(): Promise<Response> {
+        const { id } = this.req.params as unknown as { id: string };
+
+        const garantie = id.match(/^[0-9a-fA-F]{24}$/) && await this.garantieRepository.findOneOrFail(id);
+        if (garantie) {
+             return this.res.status(200).send(garantie);
+        } else {
+             return this.res.status(404).send({ text: "not found" });
+        }
+    }
+
+    /**
+     * Ajouter
+     */
+    public async add(): Promise<Response> {
+        const garantie: Garantie = plainToClass(Garantie, this.req.body);
+        const result = await this.garantieRepository.save(garantie);
+        return this.res.status(200).send(result);
+    }
+    /**
+     * Update
+     */
+    public async update(): Promise<Response> {
+        const { id } = this.req.params as unknown as { id: string };
+        const garantie: Garantie = id.match(/^[0-9a-fA-F]{24}$/) && await this.garantieRepository.findOneOrFail(id);
+
+        if (garantie) {
+            this.garantieRepository.merge(garantie, this.req.body);
+            const results = await this.garantieRepository.save(garantie);
+
+            return this.res.status(200).send(results);
+        } else {
+            return this.res.status(404).send({ message: "not found" });
+        }
+    }
+
+    /**
+     * Supprimer
+     */
+    public async delete(): Promise<Response> {
+        const { id } = this.req.params as unknown as { id: string };
+        const garantie: Garantie = id.match(/^[0-9a-fA-F]{24}$/) && await this.garantieRepository.findOneOrFail(id);
+        if (garantie) {
+            await this.garantieRepository.delete(garantie);
+            return this.res.status(200).send({message: "Garantie a bien été supprimé"});
+        } else {
+            return this.res.status(404).send({ message: "not found" });
+        }
+    }
+
+
+}

app/core/Controller.ts

@@ -0,0 +1,12 @@
+import * as express from "express";
+
+export abstract class Controller {
+
+    public req: express.Request;
+    public res: express.Response;
+
+    constructor(req: express.Request, res: express.Response) {
+        this.req = req;
+        this.res = res;
+    }
+}

app/core/Router.ts

@@ -0,0 +1,24 @@
+/**
+ * @Ta0uf19
+ */
+import * as express from "express";
+
+export abstract class Router {
+
+    public router: express.Router;
+    private controller: any;
+
+    constructor(controller: any) {
+        this.controller = controller;
+        this.router = express.Router();
+    }
+
+    /**
+     * Passing method of a controller to call
+     * @param action
+     */
+    protected handler(action: () => void): any {
+        return (req: Request, res: Response) => action.call(new this.controller(req, res));
+    }
+
+}

app/middleware/Validator.ts

@@ -0,0 +1,25 @@
+/**
+ * Validation error middlware
+ * @Ta0uf19
+ */
+import * as express from 'express';
+import {Validator} from 'class-validator';
+import {plainToClass} from "class-transformer";
+
+
+export function validator<T>(type: any): express.RequestHandler {
+
+    return (req: express.Request, res: express.Response, next: express.NextFunction) => {
+        const params = req.method === "GET" ? req.params : req.body;
+        let input = plainToClass(type, params);
+        let validator = new Validator();
+
+        let errors = validator.validateSync(input);
+        if (errors.length > 0) {
+            res.status(400).json({errors: errors}).end();
+        } else {
+            next();
+        }
+
+    };
+}

app/models/Garantie.ts

@@ -0,0 +1,23 @@
+import {Entity, ObjectID, ObjectIdColumn, Column, BeforeInsert, BeforeUpdate} from "typeorm";
+import {IsNumber} from 'class-validator';
+
+@Entity({ name: "garantie" })
+export class Garantie {
+
+    @ObjectIdColumn()
+    id: ObjectID;
+
+    @Column()
+    nom: string;
+
+    @Column()
+    @IsNumber({}, {
+        message: "Le montant doit être un nombre"
+    })
+    montant: number;
+
+    @Column()
+    description: string;
+
+
+}

app/routes/GarantieRouter.ts

@@ -0,0 +1,16 @@
+import {Router} from "../core/Router";
+import {GarantieController} from "../controllers/GarantieController";
+import {validator} from "../middleware/Validator";
+import {Garantie} from "../models/Garantie";
+
+export class GarantieRouter extends Router {
+    constructor() {
+        super(GarantieController);
+        this.router
+            .get("/", this.handler(GarantieController.prototype.all))
+            .post('/', validator(Garantie), this.handler(GarantieController.prototype.add))
+            .get('/:id', this.handler(GarantieController.prototype.find))
+            .put('/:id', validator(Garantie), this.handler(GarantieController.prototype.update))
+            .delete('/:id', this.handler(GarantieController.prototype.delete))
+    }
+}