Javascript 如何跨多个模块访问节点acl？

我在理解如何使用with mongoose模块时遇到一些问题。我可以让它运行良好，只要一切都在一个文件。但是，如果我想将路由分解为单独的文件，如何访问其他模块中的acl实例

我可以让acl很好地使用以下代码。它初始化、在数据库中创建集合，并向用户添加权限

// App.js
const mongoose = require('mongoose');
const node_acl = require('acl');
const User = require('./models/User');

mongoose.connect(/* connection string */);

acl = new node_acl(new node_acl.mongodbBackend(mongoose.connection.db, '_acl'));
acl.allow([
  {
    roles: ['guest'],
    allows: [{ resources: 'login', permissions: 'get' }],
  },
  {
    roles: ['admin'],
    allows: [{ resources: '/users', permissions: '*' }]
  }
]);

var user = User.findOne({username: 'coffee'}, (err, user) => {
  console.error(user.id);
  acl.addUserRoles(user.id, 'admin');
});

我不明白的是如何在另一个模块中正确访问acl实例，就像这样

// routes/foo.js
const acl = require('acl');
const router = require('express').Router();

// initialize acl ?

router.route('/', acl.middleware(/* rules */), (req, res) => {
  // route logic
});

module.exports = router;

此代码产生以下错误：

TypeError:acl.middleware不是函数

是否需要在每个路由模块中使用数据库连接创建新的acl实例？如果是这样的话，从猫鼬那里再次获得连接的最佳方式是什么？如果没有，或者是否有办法将其传递到每条路线

---

谢谢大家!

您可以按请求变量共享对象：

app.js:

acl = new node_acl( new node_acl.mongodbBackend(mongoose.connection.db, '_acl'));
// add this before routers:
app.use( function( req, res, next) {
  req.acl = acl;
  next();
}); 

router.route('/', (req, res) => {
  console.log(req.acl);
  // route logic
});  

routes/foo.js:

acl = new node_acl( new node_acl.mongodbBackend(mongoose.connection.db, '_acl'));
// add this before routers:
app.use( function( req, res, next) {
  req.acl = acl;
  next();
}); 

router.route('/', (req, res) => {
  console.log(req.acl);
  // route logic
});  

---

我建议创建一个帮助器模块，用于初始化acl。然后，您可以在可能需要它的任何其他模块（如路由）中使用它。

正如IOInterrupt建议的那样，您应该创建一个帮助器模块，下面是我如何使它工作的：

security.js

'use strict';

var node_acl = require('acl'),
    log = require('../log')(module),
    redis = require('../db/redis'),
    acl;

var redisBackend = new node_acl.redisBackend(redis, 'acl');
acl = new node_acl(redisBackend, log);
set_roles();

function set_roles () {

    acl.allow([{
        roles: 'admin',
        allows: [{
                resources: '/api/conf',
                permissions: '*'
            }
        ]
    }, {
        roles: 'user',
        allows: [{
            resources: 'photos',
            permissions: ['view', 'edit', 'delete']
        }]
    }, {
        roles: 'guest',
        allows: []
    }]);

    acl.addUserRoles('5863effc17a181523b12d48e', 'admin').then(function (res){
        console.log('Added myself ' + res);
    }).catch(function (err){
        console.log('Didnt worked m8' + err);
    });

}

module.exports = acl;

// .. a bunch of other stuff 
var app = express();

require('./config/express')(app);
require('./config/routes')(app, jwtauth.jwtCheck);
require('./config/security'); // just like this

connect().on('error', console.log)
         .on('disconnected', connect)
         .once('open', function (){
            log.info('Connected to DB!!!');
         });
// .. a bunch of other stuff 

    log = require(libs + 'log')(module),
    acl = require('../config/security'),
    isauth = require(libs + 'auth/isAuthorized'),
    redis = require('../db/redis');

//               This is where the magic ensues
router.get('/', acl.middleware(2,isauth.validateToken,'view'), function (req, res) {
    Conf.findById(req.query.id).then(function (conf) {
        return res.json(conf);
    }).catch(function (err) {

我第一次在app.js上调用它

app.js

'use strict';

var node_acl = require('acl'),
    log = require('../log')(module),
    redis = require('../db/redis'),
    acl;

var redisBackend = new node_acl.redisBackend(redis, 'acl');
acl = new node_acl(redisBackend, log);
set_roles();

function set_roles () {

    acl.allow([{
        roles: 'admin',
        allows: [{
                resources: '/api/conf',
                permissions: '*'
            }
        ]
    }, {
        roles: 'user',
        allows: [{
            resources: 'photos',
            permissions: ['view', 'edit', 'delete']
        }]
    }, {
        roles: 'guest',
        allows: []
    }]);

    acl.addUserRoles('5863effc17a181523b12d48e', 'admin').then(function (res){
        console.log('Added myself ' + res);
    }).catch(function (err){
        console.log('Didnt worked m8' + err);
    });

}

module.exports = acl;

// .. a bunch of other stuff 
var app = express();

require('./config/express')(app);
require('./config/routes')(app, jwtauth.jwtCheck);
require('./config/security'); // just like this

connect().on('error', console.log)
         .on('disconnected', connect)
         .once('open', function (){
            log.info('Connected to DB!!!');
         });
// .. a bunch of other stuff 

    log = require(libs + 'log')(module),
    acl = require('../config/security'),
    isauth = require(libs + 'auth/isAuthorized'),
    redis = require('../db/redis');

//               This is where the magic ensues
router.get('/', acl.middleware(2,isauth.validateToken,'view'), function (req, res) {
    Conf.findById(req.query.id).then(function (conf) {
        return res.json(conf);
    }).catch(function (err) {

然后在我的路由文件conf.js上，如下所示：

conf.js

'use strict';

var node_acl = require('acl'),
    log = require('../log')(module),
    redis = require('../db/redis'),
    acl;

var redisBackend = new node_acl.redisBackend(redis, 'acl');
acl = new node_acl(redisBackend, log);
set_roles();

function set_roles () {

    acl.allow([{
        roles: 'admin',
        allows: [{
                resources: '/api/conf',
                permissions: '*'
            }
        ]
    }, {
        roles: 'user',
        allows: [{
            resources: 'photos',
            permissions: ['view', 'edit', 'delete']
        }]
    }, {
        roles: 'guest',
        allows: []
    }]);

    acl.addUserRoles('5863effc17a181523b12d48e', 'admin').then(function (res){
        console.log('Added myself ' + res);
    }).catch(function (err){
        console.log('Didnt worked m8' + err);
    });

}

module.exports = acl;

// .. a bunch of other stuff 
var app = express();

require('./config/express')(app);
require('./config/routes')(app, jwtauth.jwtCheck);
require('./config/security'); // just like this

connect().on('error', console.log)
         .on('disconnected', connect)
         .once('open', function (){
            log.info('Connected to DB!!!');
         });
// .. a bunch of other stuff 

    log = require(libs + 'log')(module),
    acl = require('../config/security'),
    isauth = require(libs + 'auth/isAuthorized'),
    redis = require('../db/redis');

//               This is where the magic ensues
router.get('/', acl.middleware(2,isauth.validateToken,'view'), function (req, res) {
    Conf.findById(req.query.id).then(function (conf) {
        return res.json(conf);
    }).catch(function (err) {

---

不要担心在每次导入时调用mongo连接，因为在这里您将使用require（“../config/security”），所以它们都将获得相同的对象，因为导出在您第一次在app.js调用它时被缓存。我的意思是，这不会每次创建mongodb连接。

您可以使用

app.locals

在应用程序中存储全局对象

在你的

app.js中

：

app.locals.acl = acl;

然后在任何请求中，您都可以通过

req.app.locals.acl

将其取回：

route.get('/some-resource', function (req, res, next) {

    let acl = req.app.locals.acl
    ...
}

---

签出

app.locals

documentat

如果我编写了一个可以初始化acl的帮助器模块，那么它不会创建几十个到数据库的连接吗？还是只连接一次？在那个例子中，

acl.middleware（）

在处理程序中获得请求对象之前仍然未定义，所以中间件仍然无法正常工作，对吗？我得到了一个

未处理的拒绝类型错误：无法读取未定义的
错误的属性“collection”。我想这是因为我在使用mongoose，就像OP在使用一样，但你在使用redis。我可以用
mongoose.connection.on
包装它，但我不确定如何提取acl实例。