API 缓存与性能优化：CDN、查询复杂度分析与持久化查询

# 公开 API，CDN 缓存 5 分钟，过期后 1 分钟内仍可用旧数据异步回源
Cache-Control: public, max-age=300, s-maxage=300, stale-while-revalidate=60

# 用户私有数据
Cache-Control: private, max-age=60

# 不可缓存
Cache-Control: no-store

import crypto from 'crypto';

function generateETag(queryHash, dataVersion) {
  return crypto.createHash('sha256')
    .update(`${queryHash}:${dataVersion}`)
    .digest('hex').slice(0, 16);
}

res.setHeader('ETag', `"${generateETag(queryHash, data.version)}"`);

GET /graphql?query={user(id:1){name email}}&variables={}

import { ApolloServer } from '@apollo/server';
import { InMemoryLRUCache } from '@apollo/utils.keyvaluecache';

const server = new ApolloServer({
  typeDefs, resolvers,
  persistedQueries: {
    cache: new InMemoryLRUCache({ maxSize: 1000000, ttl: 86400 }),
  },
});

import { ApolloClient, InMemoryCache, HttpLink } from '@apollo/client';
import { createPersistedQueryLink } from '@apollo/client/link/persisted-queries';
import { sha256 } from 'crypto-js';

const link = createPersistedQueryLink({
  sha256: async (query) => sha256(query).toString(),
  useGETForHashedQueries: true, // hash 确认后转 GET，启用 CDN 缓存
}).concat(new HttpLink({ uri: '/graphql' }));

const client = new ApolloClient({ cache: new InMemoryCache(), link });

npx apollo client:extract \
  --endpoint=http://localhost:4000/graphql \
  --includes="src/**/*.{ts,tsx}" \
  persisted-queries.json

import fs from 'fs';

const queryMap = new Map(
  Object.entries(JSON.parse(fs.readFileSync('./persisted-queries.json', 'utf-8')))
);

const server = new ApolloServer({
  typeDefs, resolvers,
  persistedQueries: {
    cache: {
      async get(hash) { return queryMap.get(hash); },
      async set() { /* 白名单模式不存储新查询 */ },
    },
  },
});

import { createComplexityLimitRule } from 'graphql-validation-complexity';
import { GraphQLError } from 'graphql';

const complexityRule = createComplexityLimitRule(1000, {
  onComplete: (c) => console.log(`Complexity: ${c}`),
  createError: (max, actual) => new GraphQLError(
    `查询复杂度 ${actual} 超过限制 ${max}`
  ),
});

const server = new ApolloServer({
  typeDefs, resolvers,
  validationRules: [complexityRule],
});

directive @complexity(value: Int!, multipliers: [String!]) on FIELD_DEFINITION

type Query {
  user(id: ID!): User @complexity(value: 5)
  users(first: Int = 10): [User!]! @complexity(value: 5, multipliers: ["first"])
  allUsers: [User!]! @complexity(value: 500)
}

type User {
  id: ID!
  name: String! @complexity(value: 1)
  posts(first: Int = 10): [Post!]! @complexity(value: 3, multipliers: ["first"])
}

type Post {
  id: ID!
  title: String! @complexity(value: 1)
  content: String! @complexity(value: 2)
  author: User! @complexity(value: 5)
}

query {
  users(first: 20) {      # 5 × 20 = 100
    name                   # 1 × 20 = 20
    email                  # 1 × 20 = 20
    posts(first: 10) {     # 3 × 10 × 20 = 600
      title                # 1 × 200 = 200
      content              # 2 × 200 = 400
      author { name }      # 5 × 200 + 1 × 200 = 1200
    }
  }
}
# 总计：2540，超过 1000 限制，执行前被拒绝

import depthLimit from 'graphql-depth-limit';

function maxNodesRule(maxNodes) {
  return (context) => ({
    Document(node) {
      let count = 0;
      visit(node, {
        enter(n) {
          if (n.kind === 'Field') count++;
          if (count > maxNodes) {
            context.reportError(new GraphQLError(
              `查询节点数 ${count} 超过限制 ${maxNodes}`
            ));
          }
        },
      });
    },
  });
}

const server = new ApolloServer({
  typeDefs, resolvers,
  validationRules: [depthLimit(7), maxNodesRule(500)],
});

import DataLoader from 'dataloader';

async function batchUsers(ids) {
  const rows = await db.query('SELECT * FROM users WHERE id = ANY($1)', [ids]);
  const map = new Map(rows.map((r) => [r.id, r]));
  return ids.map((id) => map.get(id) || null);
}

const userLoader = new DataLoader(batchUsers);

// Resolver 中使用
const resolvers = {
  Post: {
    author: (post, _, { userLoader }) => userLoader.load(post.authorId),
  },
};

import Redis from 'ioredis';
const redis = new Redis();

function createCachedLoader(batchFn, prefix) {
  return new DataLoader(async (ids) => {
    const keys = ids.map((id) => `${prefix}:${id}`);
    const cached = await redis.mget(keys);

    const missing = [];
    const results = ids.map((id, i) => {
      if (cached[i]) return JSON.parse(cached[i]);
      missing.push(id);
      return null;
    });

    if (missing.length > 0) {
      const fetched = await batchFn(missing);
      const pipe = redis.pipeline();
      fetched.forEach((item, i) => {
        if (item) pipe.setex(`${prefix}:${missing[i]}`, 300, JSON.stringify(item));
      });
      await pipe.exec();

      let j = 0;
      for (let i = 0; i < results.length; i++) {
        if (results[i] === null) results[i] = fetched[j++] || null;
      }
    }
    return results;
  });
}

import compression from 'compression';
app.use(compression({ brotli: { quality: 4 }, level: 6 }));

import zlib from 'zlib';

app.get('/export/large-dataset', (req, res) => {
  const enc = req.headers['accept-encoding'] || '';
  res.setHeader('Content-Type', 'application/json');

  if (enc.includes('br')) {
    res.setHeader('Content-Encoding', 'br');
    const s = zlib.createBrotliCompress({
      params: { [zlib.constants.BROTLI_PARAM_QUALITY]: 4 },
    });
    s.pipe(res);
    writeLargeJson(s);
  } else if (enc.includes('gzip')) {
    res.setHeader('Content-Encoding', 'gzip');
    const s = zlib.createGzip({ level: 6 });
    s.pipe(res);
    writeLargeJson(s);
  } else {
    writeLargeJson(res);
  }
});

const wsServer = new WebSocketServer({
  port: 4000,
  perMessageDeflate: {
    zlibDeflateOptions: { level: 3 },
    clientNoContextTakeover: true,
    serverNoContextTakeover: true,
  },
});

server {
    listen 443 ssl http2;
    server_name api.example.com;

    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location /graphql {
        proxy_pass http://localhost:4000;
        proxy_http_version 1.1;
    }
}

syntax = "proto3";

service UserService {
  rpc GetUser(GetUserRequest) returns (User);
  rpc BatchGetUsers(BatchGetUsersRequest) returns (BatchGetUsersResponse);
}

message BatchGetUsersRequest { repeated string ids = 1; }
message BatchGetUsersResponse { repeated User users = 1; }
message User { string id = 1; string name = 2; string email = 3; }

import http from 'k6/http';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 },
    { duration: '5m', target: 100 },
    { duration: '2m', target: 200 },
    { duration: '2m', target: 0 },
  ],
  thresholds: {
    http_req_duration: ['p(95)<200'],
    http_req_failed: ['rate<0.01'],
  },
};

export default function () {
  const payload = JSON.stringify({
    query: `query GetUser($id:ID!){user(id:$id){name email posts(first:5){title}}}`,
    variables: { id: String(Math.floor(Math.random() * 10000) + 1) },
  });

  const res = http.post('https://api.example.com/graphql', payload, {
    headers: { 'Content-Type': 'application/json' },
  });

  check(res, {
    'status is 200': (r) => r.status === 200,
    'no errors': (r) => !JSON.parse(r.body).errors,
    'response time < 200ms': (r) => r.timings.duration < 200,
  });

  sleep(1);
}