Supongamos que está trabajando en una API de prueba, con la que cualquiera en la web puede obtener preguntas aleatorias según la categoría definida. Ha terminado con su API y ha pasado todos los parámetros de prueba, ahora, por el bien de los usuarios, desea agregar una función que les permita decidir cuántas preguntas quieren abordar y su API les proporcionará esa cantidad de preguntas. Aquí viene el útil límite de funciones de mongo .
En referencia a la documentación de mongo, el límite puede entenderse como una opción que limita la cantidad de documentos que deben pasar a la siguiente canalización para su procesamiento.
Sintaxis:
{ $limit: <positive integer> }
Para Node.js usaremos mongoose para este propósito específico. Suponiendo que haya creado un modelo de publicación para un sistema de gestión de contenido, intentemos obtener una determinada cantidad de publicaciones mediante el método find().
Javascript
Post.find().limit(5).then(posts=>{
if(!posts){
const error=new Error("No post is there to fetch");
error.statusCode=404;
throw(error);
}
return res.status(200).json({post:posts});
}).catch(err=>console.log(err));
Pase la cantidad de documentos que desea obtener como argumento para limitar. Eso es bastante abstracción, ¿verdad? No se preocupe, repasemos el proceso desde el principio.
Suponiendo una base decente de Node JS, express y mongoose. Comenzando con la creación de publicaciones y la obtención de publicaciones según el límite definido.
El flujo de trabajo para el seguimiento será:
- Configuración del entorno
- Creación de un esquema de publicación con mongoose
- Desarrollo de API para la creación de publicaciones.
- Desarrollo de API para obtener el número especificado de publicaciones de la base de datos
Configuración:
Placa Caldera:
touch app.js
Configuración de la configuración de NPM:
npm init
Instalación de dependencias:
npm i express body-parser mongoose
Estructura del proyecto: ahora, su árbol de archivos se verá un poco.
Siga los siguientes pasos uno por uno para lograr el objetivo:
Paso 1: Configuración de app.js.
Nombre de archivo: app.js
Javascript
const express = require("express");
const bodyParser = require("body-parser");
const mongoose = require("mongoose");
const app = express();
// For processing application/json
app.use(bodyParser.json());
// Setting up CORS
app.use((req, res, next) => {
res.setHeader("Access-Control-Allow-Origin", "*");
res.setHeader("Access-Control-Allow-Methods", "POST,PUT");
res.setHeader("Access-Control-Allow-Headers", "*");
next();
});
app.get("/test", (req, res, next) => {
res.send("<h1>working</h1>");
});
mongoose
.connect("mongodb://localhost:27017/articleDB")
.then(app.listen(8000, () => console.log("listening at port 8000")));
Ejecute el archivo app.js
node .\app.js
Salida: ahora al presionar localhost: 8000 / prueba, debe esperar.
Creación de un esquema posterior: los esquemas se pueden crear fácilmente en Node usando mongoose.
Javascript
// Requiring mongoose
const mongoose = require("mongoose");
// Schema of our post model
const postSchema = new mongoose.Schema(
{
title: {
type: String,
required: true,
},
content: {
type: String,
required: true,
},
},
{ timestamps: true }
);
// Model
const Post = mongoose.model("Post", postSchema);
API para la creación de publicaciones: ahora, cuando hayamos terminado de crear el modelo y los esquemas, avanzaremos creando nuestra primera API y luego probándola con Postman.
Javascript
// POST http://localhost:8000/post
app.post("/post",(req,res,next)=>{
const newPost = new Post({
title: req.body.title,
content: req.body.content,
});
newPost
.save()
.then((post) => {
return res.status(201).json({ post: post });
})
.catch((err) => {
res.status(500).json({error:err});
});
})
URL - http://localhost:8000/post Method - POST Content-Type - application/json Body of the request should contain - i. title - title of your article ii. content - content of your article
Producción:
API para obtener publicaciones según el número de publicaciones consultadas: la idea es pasar el conteo como una consulta en el punto final de la API y luego procesar esa consulta utilizando la validación básica y el límite.
Javascript
// GET http://localhost:8000/posts
app.get("/posts",(req,res,next)=>{
const requestCount = req.query.count;
Post.find()
.countDocuments()
.then((count) => {
// if requested count is more than actual count of posts in database
if (requestCount > count) {
const error = new Error("invalid request in quantity");
error.statusCode = 400;
throw error;
}
//returning posts while limiting the count
return Post.find().limit(Number(requestCount));
})
.then((posts) => {
res.status(200).json({ posts: posts });
})
.catch((err) => {
const status=error.statusCode || 500;
res.status(status).json({error:err});
});
})
limites
Publicar.encontrar().contarDocumentos()
URL - http://localhost:8000/posts/?count={limit}
Method - GET
Example Request - http://localhost:8000/posts/?count=4
Producción:
Solución final:
Nombre de archivo: app.js
Javascript
const express = require("express");
const bodyParser = require("body-parser");
// Requiring mongoose for interacting with mongoDB database
const mongoose = require("mongoose");
const app = express();
// For processing application/json
app.use(bodyParser.json());
// Setting up CORS
app.use((req, res, next) => {
res.setHeader("Access-Control-Allow-Origin", "*");
res.setHeader("Access-Control-Allow-Methods", "POST,PUT");
res.setHeader("Access-Control-Allow-Headers", "*");
next();
});
//---- mongo collection setup ----
// schema of our post model
const postSchema = new mongoose.Schema(
{
title: {
type: String,
required: true,
},
content: {
type: String,
required: true,
},
},
{ timestamps: true }
);
// model
const Post = mongoose.model("Post", postSchema);
//for testing purpose - can ignore it
app.get("/test", (req, res, next) => {
res.send("<h1>working</h1>");
});
//-----apis----------
// POST http://localhost:8000/post
app.post("/post", (req, res, next) => {
const newPost = new Post({
title: req.body.title,
content: req.body.content,
});
newPost
.save()
.then((post) => {
return res.status(201).json({ post: post });
})
.catch((err) => {
res.status(500).json({ error: err });
});
});
// GET http://localhost:8000/posts
app.get("/posts", (req, res, next) => {
const requestCount = req.query.count;
Post.find()
.countDocuments()
.then((count) => {
// if requested count is more than actual
// count of posts in database
if (requestCount > count) {
const error = new Error("invalid request in quantity");
error.statusCode = 400;
throw error;
}
// returning posts while limiting the count
return Post.find().limit(Number(requestCount));
})
.then((posts) => {
res.status(200).json({ posts: posts });
})
.catch((err) => {
const status = err.statusCode || 500;
res.status(status).json({ error: err });
});
});
// connecting to database and serving up server
mongoose
.connect("mongodb://localhost:27017/articleDB")
.then(app.listen(8000, () => console.log("listening at port 8000")));
Salida: base de datos, ahora tenemos nuestra API simple con la función de limitación de documentos habilitada.
Publicación traducida automáticamente
Artículo escrito por SubhayanSarkar y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA