0

我目前有一个 Node.js 后端运行 Express 和 Passport.js 以进行身份​​验证，并且正在尝试使用 Apollo Server 切换到 GraphQL。我的目标是实现我目前使用的相同身份验证，但无法弄清楚如何在为其他人启用授权的同时公开某些解析器。（我已经尝试广泛研究这个问题，但到目前为止还没有找到合适的解决方案。）

这是我目前的代码：

我的智威汤逊策略：

const opts = {};
opts.jwtFromRequest = ExtractJwt.fromAuthHeaderAsBearerToken();
opts.secretOrKey = JWT_SECRET;

module.exports = passport => {
  passport.use(
    new JwtStrategy(opts, async (payload, done) => {
      try {
        const user = await UserModel.findById(payload.sub);
        if (!user) {
          return done(null, false, { message: "User does not exist!" });
        }
        done(null, user);
      } catch (error) {
        done(err, false);
      }
    })
  );
}

我的 server.js 和 Apollo 配置：（ 我目前正在从 HTTP 标头中提取不记名令牌并使用上下文对象将其传递给我的解析器）：

const apollo = new ApolloServer({
  typeDefs,
  resolvers,
  context: async ({ req }) => {
    let authToken = "";

    try {
      if (req.headers.authorization) {
        authToken = req.headers.authorization.split(" ")[1];
      }
    } catch (e) {
      console.error("Could not fetch user info", e);
    }

    return {
      authToken
    };
  }
});

apollo.applyMiddleware({ app });

最后，我的解析器：

exports.resolvers = {
  Query: {
    hello() {
      return "Hello world!";
    },
    async getUserInfo(root, args, context) {
      try {
        const { id } = args;
        let user = await UserModel.findById(id);
        return user;
      } catch (error) {
        return "null";
      }
    },
    async events() {
      try {
        const eventsList = await EventModel.find({});
        return eventsList;
      } catch (e) {
        return [];
      }
    }
  }
};

我的目标是将某些查询（例如第一个（“hello”））公开，同时将其他查询限制为仅具有有效不记名令牌的请求。但是，我不确定如何专门使用 Passport.js 和 Passport-JWT 在解析器中实现此授权（通常通过将中间件添加到某些端点来完成，但是因为在此示例中我只有一个端点（/graphql） , 该选项会将所有查询限制为仅经过身份验证的用户，这不是我想要的。我必须以某种方式在解析器中执行授权，但不确定如何使用 Passport.js 中可用的工具来执行此操作。）

任何意见是极大的赞赏！

4

1 回答 1

2

我将创建一个模式指令来授权查询字段定义，然后在我想要应用授权的任何地方使用该指令。示例代码：

class authDirective extends SchemaDirectiveVisitor {
    visitObject(type) {
        this.ensureFieldsWrapped(type);
        type._requiredAuthRole = this.args.requires;
    }

    visitFieldDefinition(field, details) {
        this.ensureFieldsWrapped(details.objectType);
        field._requiredAuthRole = this.args.requires;
    }

    ensureFieldsWrapped(objectType) {
        // Mark the GraphQLObjectType object to avoid re-wrapping:
        if (objectType._authFieldsWrapped) return;
        objectType._authFieldsWrapped = true;

        const fields = objectType.getFields();

        Object.keys(fields).forEach(fieldName => {
            const field = fields[fieldName];
            const {
                resolve = defaultFieldResolver
            } = field;
            field.resolve = async function (...args) {
                // your authorization code 
                return resolve.apply(this, args);
            };
        });
    }

}

并在类型定义中声明 

directive @authorization(requires: String) on OBJECT | FIELD_DEFINITION

在您的架构中映射架构指令

....
resolvers,
schemaDirectives: {
authorization: authDirective
}

然后在您的 api 端点或任何对象上使用它

Query: {
    hello { ... }
    getuserInfo():Result @authorization(requires:authToken) {...} 
    events():EventResult @authorization(requires:authToken) {...} 
  };
于 2019-02-01T16:29:16.697 回答