Loopback REST API细粒度权限配置方案优化咨询

刚好在LoopBack里折腾过类似的细粒度权限管控需求，给你分享几个比建一堆模型角色高效得多的方案：

这是最灵活也最易维护的方案，核心思路是用一个数据库表存储每个用户对每个模型的权限配置，再通过自定义权限解析函数在请求时校验权限。

步骤1：创建权限存储模型 #

先定义一个Permission模型，专门用来存用户-模型的权限映射：

{
  "name": "Permission",
  "properties": {
    "userId": { "type": "string", "required": true },
    "modelName": { "type": "string", "required": true },
    "read": { "type": "boolean", "default": false },
    "write": { "type": "boolean", "default": false },
    "execute": { "type": "boolean", "default": false }
  },
  "indexes": {
    "user_model_unique": {
      "keys": {"userId": 1, "modelName": 1},
      "options": {"unique": true}
    }
  }
}

这个模型会确保每个用户对同一个模型只有一条权限记录，避免重复配置。

步骤2：编写自定义权限解析逻辑 #

在server/boot/permissions.js里写一个全局的权限检查函数，然后给需要管控的模型批量配置ACL：

module.exports = function(app) {
  const Permission = app.models.Permission;

  // 核心权限检查函数：根据用户ID、模型名、权限类型返回是否有权限
  async function hasModelPermission(accessType, modelName, userId) {
    if (!userId) return false; // 未登录用户直接拒绝
    const permission = await Permission.findOne({
      where: { userId, modelName }
    });
    // 没有权限记录则默认拒绝，也可以根据需求改成默认允许
    if (!permission) return false;
    switch(accessType) {
      case 'READ': return permission.read;
      case 'WRITE': return permission.write;
      case 'EXECUTE': return permission.execute;
      default: return false;
    }
  }

  // 给所有需要管控的模型统一配置ACL
  const protectedModels = ['Projects', 'Changes', 'Companies', 'ThingOne', 'ThingTwo'];
  protectedModels.forEach(modelName => {
    const model = app.models[modelName];
    model.settings.acls = model.settings.acls || [];

    // 第一步：拒绝所有未授权访问
    model.settings.acls.push({
      accessType: '*',
      principalType: 'ROLE',
      principalId: '$everyone',
      permission: 'DENY'
    });

    // 第二步：给已登录用户配置动态权限校验
    // READ权限
    model.settings.acls.push({
      accessType: 'READ',
      principalType: 'USER',
      principalId: '$authenticated',
      permission: 'ALLOW',
      resolver: async (ctx, callback) => {
        const allowed = await hasModelPermission('READ', modelName, ctx.accessToken.userId);
        callback(null, allowed);
      }
    });

    // WRITE权限
    model.settings.acls.push({
      accessType: 'WRITE',
      principalType: 'USER',
      principalId: '$authenticated',
      permission: 'ALLOW',
      resolver: async (ctx, callback) => {
        const allowed = await hasModelPermission('WRITE', modelName, ctx.accessToken.userId);
        callback(null, allowed);
      }
    });

    // EXECUTE权限
    model.settings.acls.push({
      accessType: 'EXECUTE',
      principalType: 'USER',
      principalId: '$authenticated',
      permission: 'ALLOW',
      resolver: async (ctx, callback) => {
        const allowed = await hasModelPermission('EXECUTE', modelName, ctx.accessToken.userId);
        callback(null, allowed);
      }
    });
  });
};

步骤3：管理员操作权限的API #

直接用LoopBack自动生成的Permission模型CRUD接口就行：

• 创建/更新用户权限：POST /permissions（传入userId、modelName和对应的权限布尔值）
• 修改已有权限：PUT /permissions/{id}
• 查询用户权限：GET /permissions?filter={"where":{"userId":"123"}}

这样管理员就能轻松单独切换每个用户对任意模型的权限了。

如果更喜欢用LoopBack的角色体系，可以用动态角色来实现，核心是让角色的权限判断依赖数据库中的权限记录。

步骤1：注册动态角色解析器 #

同样在server/boot/permissions.js里注册动态角色：

module.exports = function(app) {
  const Role = app.models.Role;
  const Permission = app.models.Permission;

  // 注册"模型读权限"动态角色
  Role.registerResolver('model-read', async (role, context, callback) => {
    try {
      const userId = context.accessToken?.userId;
      if (!userId) return callback(null, false);
      // 从请求上下文获取当前访问的模型名
      const modelName = context.modelName;
      const permission = await Permission.findOne({ where: { userId, modelName } });
      callback(null, permission?.read === true);
    } catch(err) {
      callback(err);
    }
  });

  // 同理注册WRITE和EXECUTE的动态角色
  Role.registerResolver('model-write', async (role, context, callback) => {
    try {
      const userId = context.accessToken?.userId;
      if (!userId) return callback(null, false);
      const modelName = context.modelName;
      const permission = await Permission.findOne({ where: { userId, modelName } });
      callback(null, permission?.write === true);
    } catch(err) {
      callback(err);
    }
  });

  Role.registerResolver('model-execute', async (role, context, callback) => {
    try {
      const userId = context.accessToken?.userId;
      if (!userId) return callback(null, false);
      const modelName = context.modelName;
      const permission = await Permission.findOne({ where: { userId, modelName } });
      callback(null, permission?.execute === true);
    } catch(err) {
      callback(err);
    }
  });
};

步骤2：给模型配置ACL #

然后在每个模型的ACL里使用这些动态角色：

"acls": [
  {
    "accessType": "*",
    "principalType": "ROLE",
    "principalId": "$everyone",
    "permission": "DENY"
  },
  {
    "accessType": "READ",
    "principalType": "ROLE",
    "principalId": "model-read",
    "permission": "ALLOW"
  },
  {
    "accessType": "WRITE",
    "principalType": "ROLE",
    "principalId": "model-write",
    "permission": "ALLOW"
  },
  {
    "accessType": "EXECUTE",
    "principalType": "ROLE",
    "principalId": "model-execute",
    "permission": "ALLOW"
  }
]

• 方案一推荐度更高：逻辑更直观，不需要额外维护角色体系，代码量也更少，适合快速落地。
• 性能优化：如果用户量和请求量较大，可以给权限查询加缓存（比如Redis），管理员修改权限时清空对应用户的缓存即可。
• 超级管理员权限：可以单独加一个$admin角色，在ACL里给这个角色所有模型的全权限，避免给管理员手动配置每条权限记录。
• 默认权限：可以在hasModelPermission函数里设置默认权限，比如新用户默认拥有所有模型的READ权限，再按需调整。

内容的提问来源于stack exchange，提问作者zatmk