如何为不同用户创建带动态Schema的NestJS GraphQL服务器

核心思路 #

放弃编译时静态生成typings的方式（依赖typePaths），改用运行时动态构建Schema+用户上下文关联的方案，因为静态typings是编译阶段生成的，无法适配每个用户的自定义Schema需求。以下是具体实现步骤：

1. 调整GraphQL模块基础配置 #

先关闭自动生成Schema和静态typings的配置，改为手动控制Schema：

@Module({
  imports: [
    GraphQLModule.forRootAsync({
      useFactory: () => ({
        autoSchemaFile: false, // 关闭自动生成Schema文件
        playground: true,
        context: ({ req }) => ({ 
          userId: req.user?.id // 从请求上下文提取用户ID，需提前做用户认证
        }),
      }),
    }),
  ],
  providers: [UserSchemaService, DynamicSchemaMiddleware],
})
export class AppModule {}

2. 实现用户Schema存储与缓存服务 #

把每个用户的自定义Schema存在数据库（如PostgreSQL/MongoDB），同时加内存缓存避免重复解析Schema：

@Injectable()
export class UserSchemaService {
  // 内存缓存，key为用户ID，value为解析好的GraphQLSchema
  private schemaCache = new Map<string, GraphQLSchema>();

  constructor(private readonly prisma: PrismaService) {}

  async getUserSchema(userId: string): Promise<GraphQLSchema> {
    // 优先从缓存获取
    if (this.schemaCache.has(userId)) {
      return this.schemaCache.get(userId);
    }

    // 从数据库读取用户自定义Schema
    const userSchemaRecord = await this.prisma.userSchema.findUnique({
      where: { userId },
    });

    // 无自定义Schema时返回默认Schema
    const schemaContent = userSchemaRecord?.content || `
      type Query {
        defaultHello: String
      }
    `;

    // 校验并编译Schema
    try {
      const executableSchema = makeExecutableSchema({
        typeDefs: schemaContent,
        resolvers: this.getDynamicResolvers(), // 绑定通用Resolver逻辑
      });
      this.schemaCache.set(userId, executableSchema);
      return executableSchema;
    } catch (err) {
      throw new BadRequestException('用户Schema格式错误');
    }
  }

  // 用户更新Schema时清除缓存
  async updateUserSchema(userId: string, schemaContent: string): Promise<void> {
    // 先校验Schema合法性
    validateSchema(buildSchema(schemaContent));
    
    await this.prisma.userSchema.upsert({
      where: { userId },
      update: { content: schemaContent },
      create: { userId, content: schemaContent },
    });
    this.schemaCache.delete(userId);
  }

  // 动态绑定Resolver，适配用户自定义的Schema字段
  private getDynamicResolvers() {
    return {
      Query: {
        // 示例：处理用户Schema中可能定义的getUserInfo字段
        getUserInfo: (_, __, { userId }) => {
          return this.prisma.user.findUnique({ where: { id: userId } });
        },
        // 可根据业务需求扩展更多通用Resolver
      },
    };
  }
}

3. 动态切换Schema中间件 #

在每个请求前根据用户ID切换ApolloServer的Schema：

@Injectable()
export class DynamicSchemaMiddleware implements NestMiddleware {
  constructor(
    @Inject(APOLLO_SERVER) private readonly apolloServer: ApolloServer,
    private readonly userSchemaService: UserSchemaService,
  ) {}

  async use(req: Request, res: Response, next: NextFunction) {
    const userId = req.user?.id;
    if (userId) {
      const userSchema = await this.userSchemaService.getUserSchema(userId);
      this.apolloServer.schema = userSchema;
    }
    next();
  }
}

4. 让Playground展示用户专属Schema #

默认Playground显示全局Schema，需自定义路由实现用户专属Playground：

@Controller('playground')
export class PlaygroundController {
  constructor(private readonly userSchemaService: UserSchemaService) {}

  @Get(':userId')
  async getCustomPlayground(@Param('userId') userId: string, @Res() res: Response) {
    const userSchema = await this.userSchemaService.getUserSchema(userId);
    // 生成带用户Schema的Playground HTML
    const playgroundHtml = renderPlaygroundPage({
      endpoint: '/graphql',
      schema: printSchema(userSchema),
    });
    res.send(playgroundHtml);
  }
}

关键注意事项 #

• 用户认证：必须确保请求上下文的userId真实有效，防止Schema泄露或越权访问
• Schema校验：用户提交自定义Schema时，必须用validateSchema校验合法性，避免运行时错误
• 缓存策略：内存缓存可结合过期时间，防止内存占用过高；也可改用Redis做分布式缓存
• 性能优化：避免每次请求都重新解析Schema，依赖缓存提升响应速度

内容的提问来源于stack exchange，提问作者Syed Muqeet Aqib