it-swarm.com.de

So erstellen Sie am besten eine RESTful-API in Node.js

Ich bin ein Anfänger in Node (und im Allgemeinen der gesamten Back-End-Webentwicklung) und habe angefangen, eine RESTful-API in Node zu schreiben. Es gibt ein paar Dinge, die ich versuche, meinen Kopf herumzubringen.

Meine Anwendung verwendet Express und Mongoose, und ich verwende das Modul express-resource, um auf einfache Weise meine CRUD-Routen für die API-Ressourcen zu erstellen. Aber es gibt ein paar Dinge, über die ich unglücklich bin, und denke, ich könnte es besser machen.

Der erste ist Mungo. Wenn ich Tests für meine API schreiben möchte, habe ich keine Möglichkeit, Mongoose zu zwingen, es in den Speicher zu zwingen. Alle Tutorials auf der Welt scheinen jedoch auf Mongoose hinzuweisen, und ich bin wirklich nicht sicher, was ich verwenden sollte.

Zweitens scheint meine Ressource viel Boilerplate-Code zu haben. Ist dies wirklich der beste Weg, um eine RESTful-API in Node.js zu erstellen? Gibt es andere Module, die mir beim Erstellen meiner CRUD-Routen helfen? Ich glaube, es gibt Möglichkeiten, wie Sie CRUD-Routen direkt aus Ihrem Schema ohne Code erstellen können, aber ich bin mir nicht sicher, wie.

Ich habe Projekte wie Tower.js und CompoundJS (formal RailwayJS) gesehen, die diese umfassenden Lösungen zu sein scheinen, die viel mehr als meine Probleme hier lösen. Vielleicht sollte ich sie verwenden, aber ich möchte wirklich nur, dass die Node.js-Anwendung eine API ist und nichts mehr. Ich beschäftige mich unabhängig von der API mit dem Frontend.

Um etwas Kontext zu geben, hier meine aktuelle Situation. Derzeit habe ich ein Modell in Mongoose definiert:

var mongoose = require('mongoose')
  , Schema = mongoose.Schema
  , Link

var LinkSchema = new Schema({
  uri: String,
  meta: {
    title: String,
    desc: String
  },
  shares: [{
    uid: Schema.Types.ObjectId,
    date: Date,
    message: String
  }]
})

Link = module.exports = mongoose.model('Link')

Als Nächstes definiere ich die Controller für die CRUD-Routen:

var mongoose = require('mongoose')
  , _ = require('underscore')
  , Link = mongoose.model('Link')

exports.load = function (req, id, fn) {
  Link.findById(req.params.link, function (err, link) {
    if (err) {
      return res.send(err)
    }

    fn(null, link)
  })
}

exports.index = function (req, res) {
  var filterByUser = req.query.user ? { 'shares.uid': req.query.user } : {}

  Link.find(filterByUser, function (err, links) {
    if (err) {
      return res.send(err)
    }

    res.send(links)
  })
}

exports.create = function (req, res) {
  var link = new Link(req.body)

  link.save(function (err) {
    if (err) {
      // TODO: send 404
      return res.send(err)
    }

    res.send(link)
  })
}

exports.show = function (req, res) {
  res.send(req.link)
}

exports.update = function (req, res) {
  req.link = _(req.link).extend(req.body)

  req.link.save(function (err, link) {
    if (err) {
      return res.send(err)
    }

    res.send(link)
  })
}

exports.patch = exports.update

exports.destroy = function (req, res) {
  req.link.remove(function (err) {
    if (err) {
      return res.send(err)
    }

    res.send()
  })
}

Zum Schluss verwende ich das Modul express-resource, um diese Controller den erforderlichen CRUD-Routen über der Express-App zuzuordnen.

app.resource('api/links', require('../resources/links'))
45
user1082754

Sie sollten in wiederherstellen schauen

Wenn Sie express verwenden möchten, können Sie auch dieses von mir erstellte Projekt - genannt node-restful - überprüfen.

Diese Bibliothek scheint viel ausgereifter zu sein und verfügt über mehr Funktionen: https://github.com/jspears/mers

29
Benoir

Strongloop Loopback ist eine weitere gute Alternative zum Erstellen von Node/MongoDB-APIs. Es können auch Moccatests generiert werden.

5
Sean McClory

Werfen Sie einen Blick auf Hapi ein konfigurationsorientiertes Framework zum Erstellen von Webanwendungen und APIs, die als restful Service verwendet werden.

Andere Optionen sind sails.js und actionhero

4
ramon22

Strapi ist ein neues (2015) Framework.

Über die Admin-Benutzeroberfläche ihrer Website können Sie eine API erstellen und Beziehungen zwischen Modellen festlegen. (Wie in ihrem Einführungsvideo zu sehen ist.)

Es ist jedoch für die Ausführung auf dem Koa-Server ausgelegt, nicht auf Express.

4
joeytwiddle

Hier sind die Fragen zu den Frameworks heutzutage.

Wenn Sie von Google hierher kommen und nach "bestem", "schnellstem" Rahmen suchen, blah, blah, werden die Leute eine Zeile mit der Aufschrift "Hey, Sie sollten diese sails.js, Federn, Derby etc ..." ausprobieren. 

Ok Die Frage ist: - Sind Sie nur zum Spaß mit diesen Frameworks? Wenn ja, können Sie leicht eine Liste von Frameworks erhalten und dann mit dem Benchmarking beginnen.

  • Ich gehe davon aus, dass die meisten Menschen "Ich möchte ein Produkt bauen, eine Website bauen kann Geld verdienen oder zumindest wird es populär werden"; 

Ok, alles, was Sie hier suchen, ist falsch. Versuchen Sie, diese Suchbegriffe dann nach "produktionsbereit", "betriebsbereit", "Fallstudie" zu durchsuchen. Oder gehen Sie zu www.wyte.com und suchen Sie nach node.js node.js Framework, das die meisten Unternehmen verwenden, die Antwort lautet einfach "express".

wenn ja, Von node.js stack: Die Frameworks werden ein paar davon ziemlich eingegrenzt: Hapi, Strongloop oder gar kein beliebter Mojito von Yahoo

Für diese Frameworks kann man zumindest sagen - "Sie sind wirklich produktions- oder betriebsbereit" - weil sie von Walmart, von Yahoo, von anderen großen Giganten aus einiger Zeit verwendet wurden, einige sogar schon seit einigen Jahren.

Kann das erklären, warum Ruby on Rails und Django noch immer die Märkte für Vollstackgerüste beherrschen? Sogar viele coole Frameworks kommen auf den Markt, Meteor, Sails.js, Go's Revel, Javas Play Spark, was auch immer Sie nennen können. Das bedeutet nicht, dass diese Frameworks schlechter sind als die beiden. Sie brauchen nur Zeit den Markt gewinnen.

Andere Probleme Viele der aktuellen Frameworks sind eine Art All-in-One-Klon von "Ror"; Aus Sicht des Endbenutzers: Sie brauchen nur etwas, um ihnen zu helfen, Dinge zu erledigen, brauchen Produktivität, brauchen etwas von Anfang bis Ende, wie Ruby on Rails, wie MacOS, wie Windows, wie alles, was getestet wurde Zu der Zeit wurde täglich von Menschen genutzt. 

2
elawcn

Ich empfehle Baucis + Express. Tausende Anwender, modellgetriebenes Design basierend auf Mongoose, sehr flexibel, spezifikationskonform, HATEOAS/Level 3 ready Passt all meine Bedürfnisse perfekt. Aber dann bin ich der Autor :) https://github.com/wprl/baucis

2
wprl

Überprüfen Sie dies heraus:  enter image description here

Mit Feathers können Sie innerhalb von Minuten Prototypen erstellen und in Echtzeit fertige Backends und REST APIs in Tagen erstellen. Ernst.

2
yokodev

Versuchen Sie https://hivepod.io/ und erstellen Sie Ihr Beispiel in einem vollständigen MEAN-Stapel. Hivepod baut auf BaucisJS + ExpressJS + MongoDB + AngularJS auf.

Haftungsausschluss: Ich arbeite am Aufbau von Hivepod.

0
pjmolina
    var mongoose        = require('../DBSchema/SchemaMapper');
    var UserSchema      = mongoose.model('User');

    var UserController = function(){
        this.insert = (data) => {
            return new Promise((resolve, reject) => {
                var user = new UserSchema({
                    userName: data.userName,
                    password: data.password
                });
                user.save().then(() => {
                    resolve({status: 200, message: "Added new user"});
                }).catch(err => {
                    reject({status: 500, message: "Error:- "+err});
                })
            })

        }

        this.update = (id, data) => {
            return new Promise((resolve, reject) => {
                UserSchema.update({_id: id}, data).then(() => {
                    resolve({status: 200, message: "update user"});
                }).catch(err => {
                    reject({status: 500, message: "Error:- " + err});
                })
            })
        }

        this.searchAll = () => {
            return new Promise((resolve, reject) => {
                UserSchema.find().exec().then((data) => {
                    resolve({status: 200, data: data});
                }).catch(err => {
                    reject({status: 500, message: "Error:- " + err});
                })
            })
        }

        this.search = (id) => {
            return new Promise((resolve, reject) => {
                UserSchema.find({_id:id}).exec().then(user => {
                    resolve({status: 200, data: user});
                }).catch(err => {
                    reject({status: 500, message: "Error:- " + err});
                })
            })
        }

        this.delete = (id) => {
            return new Promise((resolve, reject) => {
                UserSchema.remove({_id:id}).then(() => {
                    resolve({status: 200, message: "remove user"});
                }).catch(err => {
                    reject({status: 500, message:"Error:- " + err});
                })
            })
        }
    }

    module.exports = new UserController();

    ///Route
    var express     = require('express');
    var router      = express.Router();
    var Controller  = require('./User.Controller');



    router.post('/', (req, res) => {
        Controller.insert(req.body).then(data => {
            res.status(data.status).send({message: data.message});
        }).catch(err => {
            res.status(err.status).send({message: err.message});
        })
    });

    router.put('/:id', (req, res) => {
        Controller.update(req.params.id, req.body).then(data => {
            res.status(data.status).send({message: data.message});
        }).catch(err => {
            res.status(err.status).send({message: err.message});
        })
    });

    router.get('/', (req, res) => {
        Controller.searchAll().then(data => {
            res.status(data.status).send({data: data.data});
        }).catch(err => {
            res.status(err.status).send({message: err.message});
        });
    });

    router.get('/:id', (req, res) => {
        Controller.search(req.params.id).then(data => {
            res.status(data.status).send({data: data.data});
        }).catch(err => {
            res.status(err.status).send({message: err.message});
        });
    });

    router.delete('/:id', (req, res) => {
        Controller.delete(req.params.id).then(data => {
            res.status(data.status).send({message: data.message});
        }).catch(err => {
            res.status(err.status).send({message: err.message});
        })
    })

    module.exports = router;

//db`enter code here`schema

var mongoose = require('mongoose');
const Schema = mongoose.Schema;

var Supplier =new Schema({

    itemId:{
        type:String,
        required:true
    },
    brand:{
        type:String,
        required:true
    },
    pno:{
        type:String,
        required:true
    },   
    email:{
        type:String,
        required:true
    }    

});

mongoose.model('Inventory',Inventory);
mongoose.model('Supplier',Supplier);

mongoose.connect('mongodb://127.0.0.1:27017/LAB', function (err) {
    if (err) {
        console.log(err);
        process.exit(-1);
    }
    console.log("Connected to the db");
});
module.exports = mongoose;
0
Thilina Imalka

Dies ist ein Beispiel zum Ausführen von CRUD-Operationen in einem Bibliothekssystem.

var schema=require('../dbSchema');
var bookmodel=schema.model('book');

exports.getBooks = function (req,res) {
    bookmodel.find().exec().then((data)=>{
        res.send(data)
    }).catch((err)=>{
        console.log(err);
    });
};

exports.getBook = function (req,res) {
var bkName=req.params.Author;
bookmodel.find({Name:bkName}).exec().then((data)=>{
    res.send(data)
}).catch((err)=>{
    console.log(err);
});
};

exports.getAutBooks = function (req,res) {
    bookmodel.find({},'Author').then((data)=>{
        res.send(data);
    }).catch((err)=>{
    console.log(err);
    });
};

exports.deleteBooks=function(req,res){
    var bkName=req.params.name;
    bookmodel.remove({Name:bkName}).exec().then((data)=>{
        res.status(200);
        console.log(bkName);
    }).catch((err)=>{
        console.log(err);
    });
    };

exports.addBooks=function(req,res){
    var newBook=new bookmodel({
        Name:req.body.Name,
       ISBN:req.body.ISBN,
       Author:req.body.Author,
       Price:req.body.Price,
       Year:req.body.Year,
       Publisher:req.body.Publisher
    });
    newBook.save().then(()=>{
        res.status(201);
    }).catch((err)=>{
        console.log(err);
    });
};
0
Ashane.E

Ich habe Express verwendet, um meine RESTful-APIs auf Node.js zu erstellen. Mit dem Hinzufügen von Routern in Express 4 ist es noch einfacher, sie zu strukturieren. Es ist detailliert hier http://www.codekitchen.ca/guide-to-structuring-and-building-a-restful-api-using-express-4/

0
Tolga E

Schau mal in diesen link

Dieses Projekt basiert auf der gleichen Projektarchitektur, auf die ASP.Net WebApi 2.0 folgt. Das heißt, es werden Controller, Authentifizierungsmechanismen usw. zur Verfügung stehen. Sie müssen lediglich Ihre eigenen Controller erstellen.

0
Rahul Pal

Ich bin ein großer Fan von Express und benutze es, um RESTful-APIs auf Node.js zu erstellen, die einfacher zu erstellen sind. Als unsere Anwendung zu wachsen begann, endeten wir jedoch in einer Situation, in der die Express-Struktur nicht gut skaliert wurde und mehr Code aufgeteilt wurde. Das war schwieriger für uns, sie aufrechtzuerhalten.

Ich habe einen C #/Java-Hintergrund, in dem die Prinzipien von SOLID häufig verwendet werden. Frameworks wie Java Spring / C# WebAPI können nachweislich Anwendungen auf Unternehmensebene erstellen. Ich wollte ein Framework haben, in dem ich meine vorhandenen C #/Java-Kenntnisse (reuse I mean MVC architecture, OOPS, SOLID, DI, Mocks ... yeah, strong typing) wiederverwenden kann. Leider habe ich kein Framework gefunden, das meinen Anforderungen entspricht (It should have less learning curve, minimalist codebase size, completely express compatible).

Was meine ich mit vollständig expresskompatibel? Was auch immer der Express tut, ich muss es auch können, wenn ich darüber hinaus ein Framework verwende, wenn ich in Strongloop Loopback nachgesehen habe -/es war ziemlich gut zu bedienen, aber es hatte eine Menge Dokumentation durch und die Frameworks sind gekoppelt, nicht wirklich was ich gesucht habe.

Also habe ich Dinoloop von TypeScript (has interfaces, classes, abstract classes and strong oops) erstellt. Das Paket ist jetzt ziemlich stabil.

Mit Dinoloop können Sie Anwendungen auf Enterprise-Ebene in einer skalierbaren Architektur erstellen .. _. Sie verwendet das Abhängigkeitsinjektions-Framework, Sie können jedoch alle in TypeScript verfügbaren DI-Frameworks konfigurieren. Mit Dinoloop kann TypeScript als Nodejs REST - Framework verwendet werden, das mir half, die allgemeine TypeScript-Codebase für angular- und node-Projekte zu verwalten.

Daher ist Dinoloop die perfekte Lösung für TypeScript-Liebhaber und Winkelentwickler.

0
user3205479

Ich bin überrascht, dass niemand Nodal erwähnt hat.

Von der Website:

Nodal ist ein Webserver für Node.js, der für die schnelle und effiziente Erstellung von API-Services optimiert ist.

Nodal verfügt über ein eigenes, überzeugtes, eindeutiges, idiomatisches und stark erweiterbares Framework und kümmert sich um alle harten Entscheidungen für Sie und Ihr Team. Auf diese Weise können Sie sich darauf konzentrieren, in kurzer Zeit ein effektives Produkt zu entwickeln und gleichzeitig die technische Verschuldung zu minimieren

Es wird aktiv gewartet, verfügt über mehr als 3800 Sterne auf Github (zum Zeitpunkt des Schreibens), hat ein Befehlszeilentool zum Erstellen von Zusatzcode, und insgesamt ist die Arbeit schnell erledigt.

0
amaurymartiny