Comment autoriser CORS?

j'ai trouvé que la façon la plus facile est d'utiliser le noeud.paquet js cors . L'usage le plus simple est:

var cors = require('cors')

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

Il y a bien sûr plusieurs façons de configurer le comportement de vos besoins; la page liée ci-dessus montre un certain nombre d'exemples.

essayez de passer le contrôle à la prochaine route correspondante. Si Express correspond à app.obtenir route d'abord, puis il ne va pas continuer sur la route d'options à moins que vous ne fassiez ce (notez l'utilisation de la prochaine) :

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

    next();
});

en termes d'organisation des affaires CORS, Je l'ai mis dans un middleware qui fonctionne bien pour moi:

//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'));
});

Pour rester dans la même idée de routage. J'utilise ce code:

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

similaire à http://enable-cors.org/server_expressjs.html exemple

faire

npm install cors --save

et ajoutez ces lignes dans votre fichier principal où en est votre demande.

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

j'ai fait un middleware plus complet adapté pour express ou connect. Il prend en charge les demandes OPTIONS pour la vérification avant vol. Notez qu'il permettra à CORS d'accéder à n'importe quoi, vous pourriez vouloir mettre quelques vérifications si vous voulez limiter l'accès.

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();
    }
});

installe le module cors d'expressjs. vous pouvez suivre ces étapes >

Installation

npm install cors

usage Simple (Activer toutes les requêtes CORS)

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

pour plus de détails, allez à https://github.com/expressjs/cors

Faire quelque chose comme ceci:

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();
});

test effectué avec express + node + Ionic dans les ports differente.

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();
});

installez tout d'abord cors dans votre projet. Prenez le terminal (invite de commande) et cd dans votre répertoire de projet et lancez la commande suivante:

npm install cors --save

puis prendre le serveur.js fichier et modifier le code pour ajouter ce qui suit:

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();
});

ça a marché pour moi..

cela fonctionne pour moi, comme son une mise en œuvre facile à l'intérieur des routes, im en utilisant meanjs et son bon fonctionnement, 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);

    });

il y a quelque temps, j'ai fait face à ce problème donc je l'ai fait pour autoriser CORS dans mon application nodejs:

D'abord vous besoin d'installer cors en utilisant la commande ci-dessous:

npm install cors --save

maintenant ajouter le code suivant à votre application démarrer le fichier comme ( 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);

si vous voulez le rendre spécifique au contrôleur, vous pouvez utiliser:

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');

veuillez noter que cela permettra également les iframes.

Ma solution la plus simple à Exprimer 4.2.0 (EDIT: Ne semble pas fonctionner en 4.3.0) a été:

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
});

je suppose que faire app.all('/result', ...) marcherait aussi...

en plus de ce que d'autres ont dit, n'oubliez pas qu'à moins d'utiliser nodemon, vous devrez redémarrer votre serveur de noeuds pour que les changements prennent effet!

personnellement, j'avais rafraîchi mon navigateur par habitude, oubliant que c'est du code côté serveur.

j'ai trouvé qu'il était extrêmement facile de faire cela avec le paquet de requête npm ( https://www.npmjs.com/package/request )

alors j'ai basé ma solution sur ce post 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'));
});

nous pouvons éviter les CORS et transmettre les requêtes à l'autre serveur à la place:

// 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");
});

j'ai utilisé les étapes suivantes à mon application web et j'ai eu du succès:

ajouter le paquet cors à l'express:

npm install cors --save

ajouter les lignes suivantes: après la configuration du bodyParser . J'ai eu quelques difficultés à ajouter avant 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.

utilisant L'Middleware Express fonctionne très bien pour moi. Si vous utilisez déjà Express, vous n'avez qu'à ajouter les règles middleware suivantes. Il devrait commencer à travailler.

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);
});

référence

peut renvoyer le code ci-dessous pour le même. Source: Acadiemind / 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
})

ci-dessous code fonctionnera ,mais d'abord installer cors par:

npm install --enregistrer la scro

puis:

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");
});

en typographie, si vous voulez utiliser le noeud.js package 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 vous ne voulez pas utiliser les bibliothèques de troisième partie pour la gestion des erreurs cors, vous devez changer la méthode 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;

Pour l'utilisation de l'application.fichier 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);