node.js - origin - express cors github

¿Cómo permitir CORS?

Question

Estoy tratando de admitir CORS en mi aplicación Node.js que usa el marco web Express.js. He leído una discusión grupal de Google sobre cómo manejar esto y leí algunos artículos sobre cómo funciona CORS. Primero, hice esto (el código está escrito en la sintaxis de CoffeeScript):

app.options "*", (req, res) ->
  res.header ''Access-Control-Allow-Origin'', ''*''
  res.header ''Access-Control-Allow-Credentials'', true
  # try: ''POST, GET, PUT, DELETE, OPTIONS''
  res.header ''Access-Control-Allow-Methods'', ''GET, OPTIONS''
  # try: ''X-Requested-With, X-HTTP-Method-Override, Content-Type, Accept''
  res.header ''Access-Control-Allow-Headers'', ''Content-Type''
  # ...

No parece funcionar. Parece que mi navegador (Chrome) no está enviando la solicitud de OPCIONES inicial. Cuando acabo de actualizar el bloque del recurso, necesito enviar una solicitud GET de origen cruzado a:

app.get "/somethingelse", (req, res) ->
  # ...
  res.header ''Access-Control-Allow-Origin'', ''*''
  res.header ''Access-Control-Allow-Credentials'', true
  res.header ''Access-Control-Allow-Methods'', ''POST, GET, PUT, DELETE, OPTIONS''
  res.header ''Access-Control-Allow-Headers'', ''Content-Type''
  # ...

Funciona (en cromo). Esto también funciona en Safari.

He leído que ...

En un navegador que implementa CORS, cada solicitud GET o POST de origen cruzado está precedida por una solicitud OPCIONES que verifica si GET o POST están bien.

Entonces mi pregunta principal es, ¿por qué esto no parece suceder en mi caso? ¿Por qué no se llama mi bloque app.options? ¿Por qué necesito configurar los encabezados en mi bloque principal app.get?

Answer 1

Además de lo que otros han dicho, no olvide que, a menos que use nodemon, deberá reiniciar su servidor de nodo para que los cambios surtan efecto.

Personalmente había estado actualizando mi navegador por costumbre, olvidando que es el código del lado del servidor.

Answer 2

Descubrí que la forma más fácil es usar el paquete node.js cors . El uso más simple es:

var cors = require(''cors'')

var app = express()
app.use(cors())

Hay, por supuesto, muchas formas de configurar el comportamiento a sus necesidades; La página enlazada arriba muestra una serie de ejemplos.

Answer 3

El siguiente código funcionará, pero primero instale cors por:

npm instalar --save cors

Entonces:

module.exports = function(app) { 
var express = require("express");
var cors = require(''cors'');
var router = express.Router();
app.use(cors());

app.post("/movies",cors(), function(req, res) { 
res.send("test");
});

Answer 4

En escritura de tipos, si desea utilizar el paquete node.js cors

/**
* app.ts
* If you use the cors library
*/

import * as express from "express";
[...]
import * as cors from ''cors'';

class App {
   public express: express.Application;

   constructor() {
       this.express = express();
       [..]
       this.handleCORSErrors();
   }

   private handleCORSErrors(): any {
       const corsOptions: cors.CorsOptions = {
           origin: ''http://example.com'',
           optionsSuccessStatus: 200
       };
       this.express.use(cors(corsOptions));
   }
}

export default new App().express;

Si no desea utilizar bibliotecas de terceros para el manejo de errores de cors, debe cambiar el método handleCORSErrors ().

/**
* app.ts
* If you do not use the cors library
*/

import * as express from "express";
[...]

class App {
   public express: express.Application;

   constructor() {
       this.express = express();
       [..]
       this.handleCORSErrors();
   }

   private handleCORSErrors(): any {
       this.express.use((req, res, next) => {
           res.header("Access-Control-Allow-Origin", "*");
           res.header(
               "Access-Control-ALlow-Headers",
               "Origin, X-Requested-With, Content-Type, Accept, Authorization"
           );
           if (req.method === "OPTIONS") {
               res.header(
                   "Access-Control-Allow-Methods",
                   "PUT, POST, PATCH, GET, DELETE"
               );
               return res.status(200).json({});
           } 
           next(); // send the request to the next middleware
       });
    }
}

export default new App().express;

Para usar el archivo app.ts

/**
* server.ts
*/
import * as http from "http";
import app from "./app";

const server: http.Server = http.createServer(app);

const PORT: any = process.env.PORT || 3000;
server.listen(PORT);

Answer 5

Esto me funciona, ya que es una implementación fácil dentro de las rutas, estoy usando meanjs y está funcionando bien, safari, chrome, etc.

app.route(''/footer-contact-form'').post(emailer.sendFooterMail).options(function(req,res,next){ 
        res.header(''Access-Control-Allow-Origin'', ''*''); 
        res.header(''Access-Control-Allow-Methods'', ''GET, POST'');
        res.header(''Access-Control-Allow-Headers'', ''Origin, X-Requested-With, Content-Type, Accept'');
        return res.send(200);

    });

Answer 6

Hace algún tiempo, enfrenté este problema, así que hice esto para permitir CORS en mi aplicación de nodejs:

Primero necesitas instalar cors usando el siguiente comando:

npm install cors --save

Ahora agregue el siguiente código al archivo de inicio de su aplicación como ( app.js or server.js )

var express = require(''express'');
var app = express();

var cors = require(''cors'');
var bodyParser = require(''body-parser'');

//enables cors
app.use(cors({
  ''allowedHeaders'': [''sessionId'', ''Content-Type''],
  ''exposedHeaders'': [''sessionId''],
  ''origin'': ''*'',
  ''methods'': ''GET,HEAD,PUT,PATCH,POST,DELETE'',
  ''preflightContinue'': false
}));

require(''./router/index'')(app);

Answer 7

Haz algo como esto:

app.use(function(req, res, next) {
    res.header("Access-Control-Allow-Origin", "*");
    res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
    next();
});

Answer 8

He hecho un middleware más completo adecuado para Express o Connect. Es compatible con las solicitudes de OPTIONS para la verificación de verificación previa. Tenga en cuenta que permitirá el acceso de CORS a cualquier cosa, es posible que desee realizar algunas comprobaciones si desea limitar el acceso.

app.use(function(req, res, next) {
    var oneof = false;
    if(req.headers.origin) {
        res.header(''Access-Control-Allow-Origin'', req.headers.origin);
        oneof = true;
    }
    if(req.headers[''access-control-request-method'']) {
        res.header(''Access-Control-Allow-Methods'', req.headers[''access-control-request-method'']);
        oneof = true;
    }
    if(req.headers[''access-control-request-headers'']) {
        res.header(''Access-Control-Allow-Headers'', req.headers[''access-control-request-headers'']);
        oneof = true;
    }
    if(oneof) {
        res.header(''Access-Control-Max-Age'', 60 * 60 * 24 * 365);
    }

    // intercept OPTIONS method
    if (oneof && req.method == ''OPTIONS'') {
        res.send(200);
    }
    else {
        next();
    }
});

Answer 9

Instalar el módulo cors de expressjs. Puedes seguir estos pasos>

Instalación

npm install cors

Uso simple (Habilitar todas las solicitudes CORS)

var express = require(''express'');
var cors = require(''cors'');
var app = express();
app.use(cors());

Para más detalles, vaya a https://github.com/expressjs/cors

Answer 10

Intenta pasar el control a la siguiente ruta coincidente. Si Express coincide con la ruta app.get primero, entonces no continuará en la ruta de opciones a menos que haga esto (observe el uso de next) :

app.get(''somethingelse'', function(req, res, next) {
    //..set headers etc.

    next();
});

En cuanto a la organización del material CORS, lo puse en un middleware que funciona bien para mí:

//CORS middleware
var allowCrossDomain = function(req, res, next) {
    res.header(''Access-Control-Allow-Origin'', ''example.com'');
    res.header(''Access-Control-Allow-Methods'', ''GET,PUT,POST,DELETE'');
    res.header(''Access-Control-Allow-Headers'', ''Content-Type'');

    next();
}

//...
app.configure(function() {
    app.use(express.bodyParser());
    app.use(express.cookieParser());
    app.use(express.session({ secret: ''cool beans'' }));
    app.use(express.methodOverride());
    app.use(allowCrossDomain);
    app.use(app.router);
    app.use(express.static(__dirname + ''/public''));
});

Answer 11

Me resultó extremadamente fácil hacer esto con el paquete de solicitud de npm ( https://www.npmjs.com/package/request )

Luego basé mi solución en esta publicación http://blog.javascripting.com/2015/01/17/dont-hassle-with-cors/

''use strict''

const express = require(''express'');
const request = require(''request'');

let proxyConfig = {
    url : {
        base: ''http://servertoreach.com?id='',
    }
}

/* setting up and configuring node express server for the application */
let server = express();
server.set(''port'', 3000);


/* methods forwarded to the servertoreach proxy  */
server.use(''/somethingElse'', function(req, res)
{
    let url = proxyConfig.url.base + req.query.id;
    req.pipe(request(url)).pipe(res);
});


/* start the server */
server.listen(server.get(''port''), function() {
    console.log(''express server with a proxy listening on port '' + server.get(''port''));
});

Answer 12

Mi solución más simple con Express 4.2.0 (EDIT: no parece funcionar en 4.3.0) fue:

function supportCrossOriginScript(req, res, next) {
    res.status(200);
    res.header("Access-Control-Allow-Origin", "*");
    res.header("Access-Control-Allow-Headers", "Content-Type");

    // res.header("Access-Control-Allow-Headers", "Origin");
    // res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
    // res.header("Access-Control-Allow-Methods","POST, OPTIONS");
    // res.header("Access-Control-Allow-Methods","POST, GET, OPTIONS, DELETE, PUT, HEAD");
    // res.header("Access-Control-Max-Age","1728000");
    next();
}

// Support CORS
app.options(''/result'', supportCrossOriginScript);

app.post(''/result'', supportCrossOriginScript, function(req, res) {
    res.send(''received'');
    // do stuff with req
});

Supongo que hacer app.all(''/result'', ...) también funcionaría ...

Answer 13

Para mantenerse en la misma idea de enrutamiento. Yo uso este código:

app.all(''/*'', function(req, res, next) {
  res.header("Access-Control-Allow-Origin", "*");
  res.header("Access-Control-Allow-Headers", "X-Requested-With");
  next();
});

Similar a http://enable-cors.org/server_expressjs.html ejemplo

Answer 14

Para responder a su pregunta principal, la especificación CORS solo requiere que la llamada OPTIONS preceda a POST o GET si POST o GET tiene un contenido o encabezados no simples.

Los tipos de contenido que requieren una solicitud previa al vuelo de CORS (la llamada de OPCIONES) son cualquier tipo de contenido, excepto los siguientes :

1. application/x-www-form-urlencoded
2. multipart/form-data
3. text/plain

Cualquier otro tipo de contenido aparte de los enumerados anteriormente activará una solicitud previa al vuelo.

En cuanto a los encabezados, cualquier encabezado de solicitud aparte de lo siguiente activará una solicitud previa al vuelo:

1. Accept
2. Accept-Language
3. Content-Language
4. Content-Type
5. DPR
6. Save-Data
7. Viewport-Width
8. Width

Cualquier otro encabezado de solicitud activará la solicitud previa al vuelo.

Por lo tanto, podría agregar un encabezado personalizado como: x-Trigger: CORS , que debería activar la solicitud previa al vuelo y golpear el bloque de OPCIONES.

Consulte la referencia de la API web de MDN - Solicitudes de CORS con vista previa

Answer 15

Podemos evitar CORS y reenviar las solicitudes al otro servidor:

// config:
var public_folder = __dirname + ''/public''
var apiServerHost = ''http://other.server''

// code:
console.log("starting server...");

var express = require(''express'');
var app = express();
var request = require(''request'');

// serve static files
app.use(express.static(public_folder));

// if not found, serve from another server
app.use(function(req, res) {
    var url = apiServerHost + req.url;
    req.pipe(request(url)).pipe(res);
});

app.listen(80, function(){
    console.log("server ready");
});

Answer 16

Primero simplemente instala cors en tu proyecto. Lleve el terminal (indicador de comandos) y cd a su directorio de proyecto y ejecute el siguiente comando:

npm install cors --save

Luego tome el archivo server.js y cambie el código para agregar lo siguiente:

var cors = require(''cors'');


var app = express();

app.use(cors());

app.use(function(req, res, next) {
   res.header("Access-Control-Allow-Origin", "*");
   res.header(''Access-Control-Allow-Methods'', ''DELETE, PUT, GET, POST'');
   res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
   next();
});

Esto funcionó para mí ..

Answer 17

Pruebas realizadas con Express + node + ionic corriendo en diferentes puertos.

Localhost:8100

Localhost:5000

// CORS (Cross-Origin Resource Sharing) headers to support Cross-site HTTP requests

app.all(''*'', function(req, res, next) {
       res.header("Access-Control-Allow-Origin", "*");
       res.header("Access-Control-Allow-Headers", "X-Requested-With");
       res.header(''Access-Control-Allow-Headers'', ''Content-Type'');
       next();
});

Answer 18

Puede referirse al siguiente código para el mismo. Fuente: Academind/node-restful-api

const express = require(''express'');
const app = express();

//acts as a middleware
//to handle CORS Errors
app.use((req, res, next) => { //doesn''t send response just adjusts it
    res.header("Access-Control-Allow-Origin", "*") //* to give access to any origin
    res.header(
        "Access-Control-Allow-Headers",
        "Origin, X-Requested-With, Content-Type, Accept, Authorization" //to give access to all the headers provided
    );
    if(req.method === ''OPTIONS''){
        res.header(''Access-Control-Allow-Methods'', ''PUT, POST, PATCH, DELETE, GET''); //to give access to all the methods provided
        return res.status(200).json({});
    }
    next(); //so that other routes can take over
})

Answer 19

Si desea que sea específico para el controlador, puede utilizar:

res.setHeader(''X-Frame-Options'', ''ALLOWALL'');
res.setHeader(''Access-Control-Allow-Origin'', ''*'');
res.setHeader(''Access-Control-Allow-Methods'', ''POST, GET'');
res.setHeader(''Access-Control-Allow-Headers'', ''Origin, X-Requested-With, Content-Type, Accept'');

Tenga en cuenta que esto también permitirá iframes.

Answer 20

Usar Express Middleware funciona muy bien para mí. Si ya está utilizando Express, simplemente agregue las siguientes reglas de middleware. Debería empezar a funcionar.

app.all("/api/*", function(req, res, next) {
  res.header("Access-Control-Allow-Origin", "*");
  res.header("Access-Control-Allow-Headers", "Cache-Control, Pragma, Origin, Authorization, Content-Type, X-Requested-With");
  res.header("Access-Control-Allow-Methods", "GET, PUT, POST");
  return next();
});

app.all("/api/*", function(req, res, next) {
  if (req.method.toLowerCase() !== "options") {
    return next();
  }
  return res.send(204);
});

Reference

Answer 21

Utilicé los siguientes pasos para mi aplicación web y tuve éxito:

Agregue el paquete de cors al expreso:

npm install cors --save

Añade las siguientes líneas después de la configuración de bodyParser . Tuve algunos problemas añadiendo antes de bodyParser:

 // enable cors to the server
const corsOpt = {
    origin: process.env.CORS_ALLOW_ORIGIN || ''*'', // this work well to configure origin url in the server
    methods: [''GET'', ''PUT'', ''POST'', ''DELETE'', ''OPTIONS''], // to works well with web app, OPTIONS is required
    allowedHeaders: [''Content-Type'', ''Authorization''] // allow json and token in the headers
};
app.use(cors(corsOpt)); // cors for all the routes of the application
app.options(''*'', cors(corsOpt)); // automatic cors gen for HTTP verbs in all routes, This can be redundant but I kept to be sure that will always work.

Answer 22

hacer

npm install cors --save

y simplemente agregue estas líneas en su archivo principal a donde va su solicitud.

const cors = require(''cors'');
const express = require(''express'');
let app = express();
app.use(cors());
app.options(''*'', cors());