5 篇博文 含有标签「GraphQL」

import loadGrpcSubgraph from '@omnigraph/grpc'
import { defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
        // gRPC 服务地址
        endpoint: 'localhost:50051',
        // Proto 文件路径
        source: 'proto/example.proto',
      })
    }
  ]
})

import loadGrpcSubgraph from '@omnigraph/grpc'
import { defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
        endpoint: 'localhost:50051'
        // 无需 source —— Mesh 通过 Reflection 自动获取
      })
    }
  ]
})

sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
  endpoint: 'localhost:50051',
  source: {
    file: 'proto/example.proto',
    load: {
      defaults: true,                    // 加载默认的 google protobuf
      includeDirs: ['proto', 'vendor']   // Proto 搜索路径
    }
  }
})

sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
  endpoint: 'grpc.example.com:443',
  source: 'proto/example.proto',
  useHTTPS: true,
  credentialsSsl: {
    rootCA: 'certs/rootCA.pem',
    certChain: 'certs/client-cert.pem',
    privateKey: 'certs/client-key.pem',
  }
})

sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
  endpoint: 'localhost:50051',
  source: 'proto/example.proto',
  requestTimeout: 200_000,  // 毫秒，默认 200000
})

sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
  endpoint: 'localhost:50051',
  source: 'proto/example.proto',
  prefixQueryMethod: ['list', 'get', 'find', 'search'],
  // findUser → Query, searchProducts → Query
  // createUser → Mutation, deleteOrder → Mutation
})

sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
  endpoint: 'localhost:50051',
  source: 'proto/example.proto',
  selectQueryOrMutationField: [
    {
      // 支持通配符 * 模式匹配
      fieldName: '*RetrieveMovies',
      type: 'Query',
    },
    {
      // 精确匹配：将 GetMovie 从默认 Query 改为 Mutation
      fieldName: 'GetMovie',
      type: 'Mutation',
    }
  ]
})

sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
  endpoint: 'localhost:50051',
  source: 'proto/example.proto',
  schemaHeaders: {
    'x-api-key': 'my-api-key'
  }
})

sourceHandler: loadGrpcSubgraph('MyGrpcApi', {
  endpoint: 'localhost:50051',
  source: 'proto/example.proto',
  metaData: {
    // 从客户端请求头动态提取 Token，传递给 gRPC Metadata
    authorization: "Bearer {context.headers['x-my-token']}",
    // 也可以设置静态值
    someStaticValue: 'MyStaticValue',
  }
})

import { loadOpenApiSubgraph } from '@graphql-mesh/compose-cli'

sourceHandler: loadOpenApiSubgraph('MyRestApi', {
  source: './openapi.yaml',
  endpoint: 'https://api.example.com/v1',
  // 运行时请求头（执行 API 调用时）
  operationHeaders: {
    // 从 Context 动态获取
    Authorization: 'Bearer {context.headers["x-my-api-token"]}',
    // 从环境变量获取
    'X-Api-Key': '{env.API_KEY}',
    // 静态值
    'Content-Type': 'application/json',
  },
  // Schema 内省请求头（构建时）
  schemaHeaders: {
    'X-Schema-Token': '{env.SCHEMA_TOKEN}',
  },
})

import {
  createPrefixTransform,
  defineConfig,
  loadGraphQLHTTPSubgraph
} from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadGraphQLHTTPSubgraph('Countries', {
        endpoint: 'https://countries.trevorblades.com'
      }),
      transforms: [
        createPrefixTransform({
          value: 'Countries_'  // 所有类型和字段添加 Countries_ 前缀
        })
      ]
    }
  ]
})

import {
  createRenameTransform,
  defineConfig,
  loadOpenApiSubgraph
} from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadOpenApiSubgraph('MyApi', {
        source: './openapi.yaml',
      }),
      transforms: [
        createRenameTransform({
          renames: [
            { from: { type: 'User', field: 'lastName' }, to: { type: 'User', field: 'surname' } },
            { from: { type: 'BookCategory' }, to: { type: 'Category' } },
          ]
        })
      ]
    }
  ]
})

import {
  createFilterSchemaTransform,
  defineConfig,
  loadOpenApiSubgraph
} from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadOpenApiSubgraph('InternalApi', {
        source: './internal-api.yaml',
      }),
      transforms: [
        createFilterSchemaTransform({
          filters: [
            'Query.getUser',
            'Query.listProducts',
            'Mutation.createUser',
          ]
        })
      ]
    }
  ]
})

import {
  createFederationTransform,
  defineConfig,
  loadGraphQLHTTPSubgraph
} from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadGraphQLHTTPSubgraph('myApi', {
        endpoint: 'http://localhost:4001/my-api'
      }),
      transforms: [
        createFederationTransform({
          // 为 Product 类型添加 @key 指令
          Product: {
            key: {
              fields: 'id',
              resolveReference: {
                fieldName: 'productById'  // 通过此查询解析引用
              }
            },
          },
          // 标记 Query 为 extend 类型
          Query: {
            extends: true
          }
        })
      ]
    }
  ]
})

createFederationTransform({
  User: {
    key: { fields: 'id' },
    resolveReference: { fieldName: 'userById' }
  }
})

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  supergraph: {
    type: 'hive',
    endpoint: 'https://cdn.graphql-hive.com/artifacts/v1/<project-id>/supergraph',
    key: 'YOUR_CDN_KEY'
  }
})

import loadGrpcSubgraph from '@omnigraph/grpc'
import { loadGraphQLHTTPSubgraph } from '@graphql-mesh/compose-cli'
import {
  createFederationTransform,
  createPrefixTransform,
  defineConfig
} from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    // ─── 子图 1：gRPC 服务 ───────────────────────
    {
      sourceHandler: loadGrpcSubgraph('InventoryService', {
        endpoint: 'localhost:50051',
        source: {
          file: 'proto/inventory.proto',
          load: {
            defaults: true,
            includeDirs: ['proto']
          }
        },
        requestTimeout: 200_000,
        useHTTPS: false,
        metaData: {
          authorization: "Bearer {context.headers['x-my-token']}",
        },
        prefixQueryMethod: ['list', 'get'],
        selectQueryOrMutationField: [
          { fieldName: '*RetrieveMovies', type: 'Query' },
          { fieldName: 'GetMovie', type: 'Mutation' },
        ],
        schemaHeaders: {
          'x-api-key': '{env.SCHEMA_API_KEY}'
        }
      }),
      transforms: [
        createPrefixTransform({ value: 'Inventory_' }),
        createFederationTransform({
          Product: {
            key: { fields: 'upc' },
            resolveReference: { fieldName: 'getProduct' }
          }
        })
      ]
    },

    // ─── 子图 2：GraphQL 服务 ─────────────────────
    {
      sourceHandler: loadGraphQLHTTPSubgraph('Users', {
        endpoint: 'http://localhost:4001/graphql',
        operationHeaders: {
          Authorization: 'Bearer {context.headers["authorization"]}',
        },
      }),
      transforms: [
        createFederationTransform({
          User: {
            key: { fields: 'id' },
            resolveReference: { fieldName: 'user' }
          }
        })
      ]
    }
  ]
})

// gateway.config.ts
import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  maxTokens: true  // 启用，默认上限 1000 个 Token
})

import { maxTokensPlugin } from '@escape.tech/graphql-armor-max-tokens'
import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  plugins: () => [
    maxTokensPlugin({
      enabled: true,
      n: 5000,                    // 允许的最大 Token 数
      propagateOnRejection: true,  // 是否向客户端返回拒绝信息
      allowList: [],               // 白名单（跳过检查的查询）
      onAccept: [],                // 接受时的回调
      onReject: [],                // 拒绝时的回调
    })
  ]
})

import { maxDepthPlugin } from '@escape.tech/graphql-armor-max-depth'
import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  plugins: () => [
    maxDepthPlugin({
      enabled: true,
      n: 6,                       // 最大嵌套深度，默认 6
      propagateOnRejection: true,
      allowList: [],
    })
  ]
})

import { maxAliasesPlugin } from '@escape.tech/graphql-armor-max-aliases'
import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  plugins: () => [
    maxAliasesPlugin({
      enabled: true,
      maxAliases: 5,              // 最大别名数，默认 5
      propagateOnRejection: true,
      allowList: [],
    })
  ]
})

import { characterLimitPlugin } from '@escape.tech/graphql-armor-character-limit'
import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  plugins: () => [
    characterLimitPlugin({
      maxLength: 15000  // 最大字符数，默认 15000
    })
  ]
})

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  rateLimiting: {
    rules: [
      {
        type: 'Query',
        field: 'foo',
        max: 5,       // 时间窗口内最大请求数
        ttl: 5000,    // 时间窗口（毫秒）
        identifier: '{context.headers.authorization}'  // 按用户限流
      }
    ]
  }
})

// gateway.config.ts
import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  rateLimiting: true  // 启用指令式限流
})

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  batching: {
    limit: 10  // 单次 HTTP 请求最多包含 10 个 GraphQL 操作，默认 10
  }
})

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  healthCheckEndpoint: '/healthcheck',    // 存活检查
  readinessCheckEndpoint: '/readiness',  // 就绪检查
})

// telemetry.ts
import { openTelemetrySetup } from '@graphql-hive/gateway/opentelemetry/setup'
import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks'
import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'

openTelemetrySetup({
  contextManager: new AsyncLocalStorageContextManager(),
  traces: {
    exporter: new OTLPTraceExporter({ url: process.env['OTLP_URL'] }),
    console: process.env['DEBUG_TRACES'] === '1'  // 调试时输出到控制台
  },
  resource: {
    serviceName: 'my-gateway',
    serviceVersion: '1.0.0'
  }
})

import './telemetry'  // 必须是第一个导入！
import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  openTelemetry: {
    traces: true
  }
})

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  prometheus: {
    enabled: true
  }
})

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  sentry: {
    dsn: 'YOUR_SENTRY_DSN'
  }
})

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  statsd: {
    host: 'localhost',
    port: 8125
  }
})

import loadGrpcSubgraph from '@omnigraph/grpc'
import { defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadGrpcSubgraph('InventoryService', {
        endpoint: 'localhost:50051',
        source: 'proto/inventory.proto',
        metaData: {
          authorization: "Bearer {context.headers['x-my-token']}",
        },
      }),
    }
  ],
  // 为 gRPC 生成的字段添加权限注解
  additionalTypeDefs: /* GraphQL */ `
    extend schema
      @link(url: "https://specs.apollo.dev/federation/v2.6",
            import: ["@authenticated", "@requiresScopes"])

    extend type Query {
      listProducts: [Product] @authenticated @requiresScopes(scopes: ["inventory:read"])
      getProduct: Product @authenticated
    }

    extend type Mutation {
      createProduct: Product @authenticated @requiresScopes(scopes: ["inventory:write"])
    }
  `
})

import './telemetry'
import { maxDepthPlugin } from '@escape.tech/graphql-armor-max-depth'
import { maxTokensPlugin } from '@escape.tech/graphql-armor-max-tokens'
import { maxAliasesPlugin } from '@escape.tech/graphql-armor-max-aliases'
import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  // ─── Supergraph 来源 ─────────────────────
  supergraph: {
    type: 'hive',
    endpoint: 'https://cdn.graphql-hive.com/artifacts/v1/<id>/supergraph',
    key: '<CDN_KEY>'
  },

  // ─── 安全防护 ───────────────────────────
  maxTokens: true,  // 内置 Token 限制（默认 1000）
  plugins: () => [
    maxDepthPlugin({ n: 7 }),           // 查询深度限制
    maxTokensPlugin({ n: 5000 }),        // Token 限制（覆盖内置）
    maxAliasesPlugin({ maxAliases: 5 }), // 别名限制
  ],

  // ─── 限流 ───────────────────────────────
  rateLimiting: {
    rules: [
      {
        type: 'Query',
        field: 'listProducts',
        max: 100,
        ttl: 60000,
        identifier: '{context.headers.authorization}'
      }
    ]
  },

  // ─── 请求批处理 ─────────────────────────
  batching: { limit: 10 },

  // ─── 健康检查 ───────────────────────────
  healthCheckEndpoint: '/healthcheck',
  readinessCheckEndpoint: '/readiness',

  // ─── 可观测性 ───────────────────────────
  openTelemetry: { traces: true },
  prometheus: { enabled: true },
})

import { defineConfig } from '@graphql-mesh/compose-cli'
import { loadGraphQLHTTPSubgraph } from '@graphql-mesh/graphql'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadGraphQLHTTPSubgraph('Posts', {
        endpoint: 'http://localhost:4001/posts'
      })
    },
    {
      sourceHandler: loadGraphQLHTTPSubgraph('Users', {
        endpoint: 'http://localhost:4002/users'
      })
    }
  ],
  additionalTypeDefs: /* GraphQL */ `
    extend type Post {
      user: User!
      @resolveTo(
        sourceName: "Users"
        sourceTypeName: "Query"
        sourceFieldName: "userById"
        requiredSelectionSet: "{ id }"
        sourceArgs: { id: "{root.userId}" }
      )
    }
    extend type User {
      posts: [Post!]!
      @resolveTo(
        sourceName: "Posts"
        sourceTypeName: "Query"
        sourceFieldName: "postsByUserId"
        requiredSelectionSet: "{ id }"
        sourceArgs: { userId: "{root.id}" }
      )
    }
  `
})

additionalTypeDefs: /* GraphQL */ `
  extend type Post {
    user: User!
    @resolveTo(
      sourceName: "Users"
      sourceTypeName: "Query"
      sourceFieldName: "usersByIds"
      keyField: "userId"
      keysArg: "ids"
    )
  }
`

import { createFilterTransform } from '@graphql-mesh/compose-cli'

// 在 Users 子图上应用
transforms: [
  createFilterTransform({
    fieldFilter: (typeName, fieldName) => fieldName !== 'usersByIds'
  })
]

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  responseCaching: {
    // 全局缓存（无 Session 隔离）
    session: () => null,
  }
})

export const gatewayConfig = defineConfig({
  responseCaching: {
    // 基于认证头隔离缓存
    session: request => request.headers.get('authorization'),
  }
})

export const gatewayConfig = defineConfig({
  responseCaching: {
    session: () => null,
    // 全局默认 TTL
    ttl: 2_000,
    // 按 Schema 坐标设置不同 TTL
    ttlPerSchemaCoordinate: {
      'Query.topProducts': 60_000,   // 60 秒
      'Query.me': 500,               // 0.5 秒
      'User': 10_000,                // User 类型相关查询 10 秒
      'Query.currentTime': 0,        // 禁止缓存
    }
  }
})

export const gatewayConfig = defineConfig({
  responseCaching: {
    session: () => null,
    idFields: ['id', 'email']  // 优先使用 id，其次 email
  }
})

import { createNamingConventionTransform, defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadOpenApiSubgraph('MyApi', {
        source: './openapi.yaml',
      }),
      transforms: [
        createNamingConventionTransform({
          typeNames: 'pascalCase',     // 类型名：PascalCase
          fieldNames: 'camelCase',     // 字段名：camelCase
          enumValues: 'UPPER_CASE',    // 枚举值：UPPER_CASE
        })
      ]
    }
  ]
})

import { createEncapsulateTransform, defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadGraphQLHTTPSubgraph('Users', {
        endpoint: 'http://localhost:4001/graphql'
      }),
      transforms: [
        createEncapsulateTransform({
          applyTo: {
            query: true,
            mutation: false,
            subscription: false
          }
        })
      ]
    }
  ]
})

import { createHoistFieldTransform, defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadGraphQLHTTPSubgraph('Users', {
        endpoint: 'http://localhost:4001/users'
      }),
      transforms: [
        createHoistFieldTransform({
          mapping: [
            {
              typeName: 'Query',
              pathConfig: ['users', 'results'],
              newFieldName: 'users'
            }
          ]
        })
      ]
    }
  ]
})

createHoistFieldTransform({
  mapping: [
    {
      typeName: 'Query',
      pathConfig: [
        { fieldName: 'users', filterArgs: ['limit'] },  // 过滤掉 limit 参数
        'results'
      ],
      newFieldName: 'users'
    }
  ]
})

import { createPruneTransform, defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadOpenApiSubgraph('MyApi', {
        source: './openapi.yaml',
      }),
      transforms: [
        createPruneTransform({
          // 可选：指定跳过的类型
          skipPruning: ['DeprecatedType']
        })
      ]
    }
  ]
})

import { defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    // ... 其他子图
  ],
  additionalTypeDefs: /* GraphQL */ `
    extend schema {
      subscription: Subscription
    }

    type Subscription {
      todoAdded: Todo
      @resolveTo(
        pubsubTopic: "webhook:post:/webhooks/todo_added"
        # 可选：过滤
        # filterBy: "root.userId === args.userId"
        # 可选：嵌套数据路径
        # result: "data.someProp.someOtherProp"
      )
    }
  `
})

import { loadJSONSchemaSubgraph } from '@omnigraph/json-schema'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadJSONSchemaSubgraph('API', {
        operations: [
          {
            type: 'Subscription' as any,
            field: 'todoAdded',
            pubsubTopic: 'webhook:post:/webhooks/todo_added',
            responseSample: './todo.json',
            responseTypeName: 'Todo'
          }
        ]
      })
    }
  ]
})

import { defineConfig } from '@graphql-hive/gateway'

export const gatewayConfig = defineConfig({
  webhooks: true  // 启用 Webhook 接收
})

import { loadOpenApiSubgraph } from '@omnigraph/openapi'
import { defineConfig } from '@graphql-mesh/compose-cli'

export const composeConfig = defineConfig({
  subgraphs: [
    {
      sourceHandler: loadOpenApiSubgraph('PaymentService', {
        source: './openapi.yaml',
        // 或远程 URL
        // source: 'https://api.example.com/openapi.json',
        endpoint: 'https://api.example.com/v1',
        operationHeaders: {
          Authorization: 'Bearer {context.headers["authorization"]}',
          'X-Request-Id': '{context.headers["x-request-id"]}',
        },
        schemaHeaders: {
          'X-Schema-Token': '{env.SCHEMA_TOKEN}',
        },
        queryParams: {
          api_key: '{env.API_KEY}',
        },
        ignoreErrorResponses: true,
      })
    }
  ]
})