I am learning and trying to understand expressjs deeply.
var express = require('express');
var app = express();
app.get('/', ...);
Could you please inform me where the app.get method is defined in the express module?
I want to learn the code flow.
All methods including app.get() are defined here followed by app.all().
Related
Imagine this sample Express app straight from the documentation:
const express = require('express')
const app = express()
app.get('/', (req, res) => {
res.send('Hello World!')
})
app.listen(3000)
What is the idiomatic way to invoke the '/' endpoint programmatically from a different point in the same application code? Assume that I already removed the last line app.listen(3000).
The reason for this is that I want to take something like express-pouchdb and write an adapter for a different wire protocol, but leveraging the extensive routes already defined. I want to invoke these routes directly from js code without going over the network.
The application has dozens of routes already defined so changing each one to direct function calls as suggested in the first comment is not an option.
UPDATE:
I tried calling app.route.dispatch() but nothing comes back on the rsp object.
Your question is a duplicate of this answer: Is it possible to call Express Router directly from code with a "fake" request?
You can use run-middleware module exactly for that. You create an express app a usual, and then you can call the app using your parameters
I have a Next.js app with an Express server in server.js (using custom server deployment.)
In the Next.js example server.js file, app.render(req, res, '/a', req.query); is used.
I understand that res.render uses app.render and that app.render is used for serving 'raw' content by means other than the HTTP protocol.
The Express docs detail that app.render takes the arguments:
app.render(view, [locals], callback)
So in the the Next.js example files, app.render(req, res, '/a', req.query);
req=view,
res=locals,
'/a'=locals,
req.query=callback
I'm struggling to make sense of the use of app.render here, and the arguments passed to it.
What are the arguments passed here, and how do they correlate with the documented express function signature?
As a supplementary question -
Next.js docs define this pattern as: This is obviously a non-standard routing strategy.
In what way is it non-standard, and why not use a standard routing pattern for example purposes?
Can someone explain this to me clearly?
const express = require("express");
const app = express();
I get the first line of code, but don't get the concept of initializing a variable "app" as express()? When we import express, we also have access to express()?
What does it do theoretically? What does that () of express() do?
Do we always have to do it like that?
Thank you.
If you are familiar with object-oriented programming, then the way to think of this is by creating an instance.
When you import express, you are importing the class. However, your server is an instance of that class. So, when you call
const app = express();
you are spinning up your server. You now have the encoding of a server you can interact with from app, whereas the original import just refers to the same class (i.e. like a template) for what that server is. The function express() is merely initializing a new server object for you.
Technically, you could have multiple 'servers' running:
const app1 = express();
const app2 = express();
You would want these to be independent of each other, which is why you don't just use the top-level import.
According to the documentation
The express() function is a top-level function exported by the express module
The function returns a app object which is essentially an Express application.
The app object has methods for
Routing HTTP requests; see for example, app.METHOD and app.param.
Configuring middleware
Rendering HTML views; see
Registering a template engine; see app.engine.
I am trying to get my head around using GCF and Express together. All of the examples I have found give good info about Firebase CF but not straight up GCF.
Specifically, I need to use body-parser to get at some POSTed body info that is being sent via a content-type of 'x-www-form-urlencoded' rather than 'application/json'. I can see the data if I console.log the req.rawBody but haven't found a clean way to get at the body parts.
I found this article: https://mhaligowski.github.io/blog/2017/05/15/serving-functions-express.html but to me it is just a couple of code snippets that really isn't clear on how things actually hang together.
You can require body-parser and as long as you send the Content-Type: application/json header, it will parse as JSON automatically:
const bodyParser = require('body-parser');
exports.acceptJson = (req, res) => {
console.log(req.body);
res.status(200);
};
I have an Express 3 app that uses bodyParser for most routes. (Most routes only accept multipart.) I have a single route that is going to be parsing files up to 1GB in size which bodyParser can't seem to handle. I would like to use multiparty for only this route so I don't have to rewrite the whole API. Is this possible?
You can supply middleware to a single route by doing this:
var multipartyMiddleware = function (req,res,next){
//put your code to parse multipart here and call "next" when done
}
app.post('/this/is/a/single/route', multipartyMiddleware, function(req,res){
//do normal business logic in this route and send the response
})
If you need to bypass the multipart parsing in the old bodyParser in express 3 you can replace this:
app.use(express.bodyParser())
with this:
app.use(express.json())
app.use(express.urlencoded())
This works because the source of the bodyParser middleware reveals that it is just a combo of three middleware parsers: multipart, json, and urlencoded.
see the connect 2.X source here: https://github.com/senchalabs/connect/blob/2.x/lib/middleware/bodyParser.js#L54