Come progettare API REST utilizzando Express, MongoDB e TypeScript.

In questo tutorial, parleremo di come progettare servizi REST in TypeScript, MongoDB ed Express.

Prerequisiti:

1. Gestione pacchetti NPM o Yarn
2. Esprimere
3. Dattiloscritto
4. Postino
5. MongoDB e Mongoose.
6. Servizi REST per TypeScript

Nel nostro progetto creeremo endpoint che creeranno, recupereranno e aggiorneranno utilizzando i metodi POST, GET e PUT. Per raggiungere questo obiettivo, useremo le funzioni Mongoose come creare () , findOne(),findOneAndUpdate()

Gli endpoint verranno creati in Express.

Installazione delle dipendenze:

1. Prima di tutto, installa Node (se non l'hai fatto) e NPM o Yarn Package Manager. Questo verrà utilizzato per installare le dipendenze sulla tua macchina.
2. Una volta installato, installa Express utilizzando npm install express @types/express --save-dev.
3. Avrai anche bisogno di MongoDB e Mongoose. Mongoose è una libreria ODM (Object Data Modeling) per MongoDB e Node.js. Gestisce le relazioni tra i dati, fornisce la convalida dello schema e viene utilizzato per tradurre tra oggetti nel codice e la rappresentazione di tali oggetti in MongoDB. Ottieni MongoDB dahttps://docs.mongodb.com/guides/server/install/ e installa Mongoose usando npm install mongoose --save.
4. Postino, per inviare e ricevere richieste API. Installalo dahttps://www.postman.com/downloads/
5. TypeScript è un linguaggio open source che si basa su JavaScript, uno degli strumenti più utilizzati al mondo, aggiungendo definizioni di tipo statico. I tipi forniscono un modo per descrivere la forma di un oggetto, fornendo una migliore documentazione e consentendo a TypeScript di verificare che il codice funzioni correttamente. Installa TypeScript usandonpm install typescript -g.
6. Ultimo, ma non meno importante, installa il pacchetto REST TypeScript da https://www.npmjs.com/package/typescript-rest. Questo è un pacchetto leggero per scrivere endpoint e percorsi utilizzando Typescript.

Digita npm init per inizializzare il progetto. Questo ti chiederà il nome del tuo progetto, l'autore, la versione, il link al repository GIT, la licenza e tutto il resto. Puoi saltarli per ora usando il comando npm init -y .

Una volta completata l'installazione di base, aggiungi alcuni script al file package.json.

"scripts": {
    "watch-ts": "tsc -w",
    "watch-node": "nodemon dist/server.js",
    "watch": "concurrently -k -p \"[{name}]\" -n \"TypeScript, Node\" -c \"yello.bold, cyan.bold\" \"yarn run watch-ts\" \"yarn run watch-node\""
}

{
  "name": <Your Project Name>,
  "version": "1.0.0",
  "main": "index.js",
  "license": "MIT",
  "scripts": {
    "watch-ts": "tsc -w",
    "watch-node": "nodemon dist/server.js",
    "watch": "concurrently -k -p \"[{name}]\" -n \"TypeScript, Node\" -c \"yello.bold, cyan.bold\" \"yarn run watch-ts\" \"yarn run watch-node\""
  },
  "dependencies": {
    "@types/express": "^4.11.1",
    "concurrently": "^3.5.1",
    "express": "^4.16.3"
  }
}

Crea un nuovo tsconfig.jsonfile nella tua directory principale e aggiungi la seguente configurazione:

{
  "compilerOptions": {
    "module": "commonjs",
    "esModuleInterop": false,
    "target": "es6",
    "noImplicitAny": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "moduleResolution": "node",
    "sourceMap": true,
    "outDir": "dist",
    "baseUrl": ".",
    "paths": {
      "*": ["node_modules/", "src/types/*"]
    }
  },
  "include": ["src/**/*"]
}

Crea il tuo file app.ts e aggiungi il seguente codice al suo interno.

import * as express from "express";
import {Server, Path, GET, PathParam} from "typescript-rest";

class Sample {
@Path("/hello:name")
@GET
 sayHello( @PathParam('name') name: string ): string {
 return "Hello " + name;
}}
let app: express.Application = express();
Server.buildServices(app);
app.listen(3000, function() {
console.log('Rest Server listening on port 3000!');
});

Connessione a MongoDB:

Crea un file db.ts e aggiungi il codice seguente. Questo blocco di codice contiene l'indirizzo locale del database.

import * as mongoose from 'mongoose';
export class myDB {
public static async initDB() {
   return mongoose.connect('mongodb://localhost:27017/local');
}
public static async closeCon() {
   return mongoose.connection.close(true);
}}

import * as express from "express";
import { myDB } from './db';
import {Server, Path, GET, PathParam} from "typescript-rest";
class Sample {
constructor(){
myDB.initDB();
}
let app: express.Application = express();
Server.buildServices(app);
app.listen(3000, function() {
console.log('Rest Server listening on port 3000!');
});

Creiamo una cartella chiamata models. Crea un file userModel all'interno della cartella dei modelli.

import * as mongoose from 'mongoose';
import { Model } from 'mongoose';
type UserType = UserModel & mongoose.Document;
export interface UserModel {
    firstname:{
        type: String,
        required: true
    }
    lastname:{
        type: String,
        required: true
    }
    mobile: {
        type: Number
    }
    age: {
        type: Number,
    }
    pincode: {
        type: Number
    }
};
const Users = new mongoose.Schema({
   firstname:{
        type: String,
        required: true
    },
    lastname:{
        type: String,
        required: true
    },
    mobile: {
        type: Number
    },
    age: {
        type: Number,
    },
    pincode: {
        type: Number
    },
});
const Users: Model<UserType> = mongoose.model<UserType>('Users', UserSchema,'Users');
export default Users;

Importiamo questo file nel nostro app.ts principale. Queste importazioni verranno utilizzate in seguito durante la creazione di corpi API, ovvero POST, GET e PUT.

import * as express from "express";
import { myDB } from './db';
import Users, { UserModel } from './models/userModel';
import {Server, Path, GET, PathParam} from "typescript-rest";
class Sample {
constructor(){
 myDB.initDB();
}
let app: express.Application = express();
Server.buildServices(app);
app.listen(3000, function() {
console.log('Rest Server listening on port 3000!');
});

Fare richieste POST:

import * as express from "express";
import { myDB } from './db';
import Users, { UserModel } from './models/userModel';
import {Server, Path, POST } from "typescript-rest";
class ExampleClass{
constructor(){
 myDB.initDB();
}
@POST
 @Path('post/users')
  public async createUser(newRecord: UserModel){
   try{
     var users = await Users.create(newRecord);
     return users; 
   }catch(e){
     console.log(e);
}};
let app: express.Application = express();
Server.buildServices(app);
app.listen(3000, function() {
console.log('Rest Server listening on port 3000!');
});

{
 “firstname”: “Nishant”,
 “lastname”: “Kumar”,
 “mobile”: 123456789,
 “age”: 24,
 “pincode”: 987654
}

Otterrai qualcosa come:

[{
 "_id":<Some Random id>
 “firstname”: “Nishant”,
 “lastname”: “Kumar”,
 “mobile”: 123456789,
 “age”: 24,
 “pincode”: 987654
}]

Allo stesso modo, puoi effettuare richieste GET e PUT.

import * as express from "express";
import { myDB } from './db’;
import Users, { UserModel } from './models/userModel’;
import {Server, Path, POST, GET, PUT, PathParam} from "typescript-rest";
import { ObjectId } from "mongodb";
class ExampleClass{
constructor(){
 myDB.initDB();
}
@POST
 @Path('post/users')
  public async createUser(newRecord: UserModel){
   try{
     var users = await Users.create(newRecord);
     return users; 
   }catch(e){
     console.log(e);
}};
@PUT
 @Path('put/users/:id')
  public async updateUser(@PathParam('id') id: ObjectId){
   try{
     var users = await Users.findOneAndUpdate({ _id: id });
     return users; 
   }catch(e){
     console.log(e);
}};
@GET
 @Path('get/users/:id')
  public async getUser(@PathParam('id') id: ObjectId){
   try{
     var users = await Users.findOne({ _id: id });
     return users; 
   }catch(e){
     console.log(e);
}};
let app: express.Application = express();
Server.buildServices(app);
app.listen(3000, function() {
console.log('Rest Server listening on port 3000!');
});

INVIARE: http://localhost:3000/post/users

METTERE: http://localhost:3000/put/users/:id

OTTENERE: http://localhost:3000/get/users/:id

È tutto. Prova e sperimenta. Buon apprendimento.