@goplus123/core-api 1.0.4 → 1.0.6

package/README.md

@@ -260,6 +260,195 @@ const sdk = initSDK({
 
 对应实现：[`initSDK`](./src/index.ts#L372-L578)
 
+### React Native：注入 gRPC invoker（解决 RN 真机解析 gRPC-Web 响应问题）
+
+当后端仅提供 gRPC-Web，而 React Native 环境下 `@connectrpc/connect-web` 的 `fetch`/二进制响应解析存在兼容性问题时，可以通过 `grpc.invoker` 注入一层“可替换的底层调用器”，在不改动上层调用方式（`sdk.xxx` / `requestApi` / spec）前提下，切换为 RN 可用的 gRPC-Web 实现。
+
+这个 `invoker` 只是一个“可插拔的 unary 调用实现”，不限定必须使用某个第三方库。
+
+`invoker.unary()` 的入参约定：
+
+- `baseUrl`：本次请求实际使用的 baseUrl（已根据 service 自动路由）
+- `service` / `methodName`：本次调用的服务与方法名
+- `method`：服务方法描述（如果可获取），用于取 input/output schema 与 rpcName
+- `request`：已经构造好的 protobuf message（上层已用 schema create 过）
+- `headers`：最终要发出去的 headers（已合并 auth/getHeaders/静态 headers 与 callOptions.headers）
+- `callOptions`：透传的调用选项（例如 timeout），按你的底层实现自行使用
+
+示例 A（推荐）：在 RN 工程内用 `fetch` 走 gRPC-Web（二进制），复用本 SDK 的 bufbuild 生成物（不需要重新编译 proto）。这个方案不需要引入 `@improbable-eng/grpc-web-react-native-transport`：
+
+```ts
+import { initSDK, fetchGuid } from '@goplus123/core-api'
+import { fromBinary, toBinary } from '@bufbuild/protobuf'
+
+function concatBytes(chunks: Uint8Array[]): Uint8Array {
+  let len = 0
+  for (const c of chunks) len += c.byteLength
+  const out = new Uint8Array(len)
+  let offset = 0
+  for (const c of chunks) {
+    out.set(c, offset)
+    offset += c.byteLength
+  }
+  return out
+}
+
+function grpcWebEncodeUnary(messageBytes: Uint8Array): Uint8Array {
+  const out = new Uint8Array(5 + messageBytes.byteLength)
+  out[0] = 0
+  const view = new DataView(out.buffer, out.byteOffset, out.byteLength)
+  view.setUint32(1, messageBytes.byteLength, false)
+  out.set(messageBytes, 5)
+  return out
+}
+
+function bytesToAscii(bytes: Uint8Array): string {
+  let s = ''
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]!)
+  return s
+}
+
+function parseGrpcWebTrailers(bytes: Uint8Array): Record<string, string> {
+  const text = bytesToAscii(bytes)
+  const out: Record<string, string> = {}
+  for (const line of text.split('\r\n')) {
+    if (!line) continue
+    const idx = line.indexOf(':')
+    if (idx < 0) continue
+    const k = line.slice(0, idx).trim().toLowerCase()
+    const v = line.slice(idx + 1).trim()
+    out[k] = v
+  }
+  return out
+}
+
+function grpcWebDecodeUnary(body: Uint8Array): { message?: Uint8Array; trailers: Record<string, string> } {
+  let offset = 0
+  let message: Uint8Array | undefined
+  let trailers: Record<string, string> = {}
+  while (offset + 5 <= body.byteLength) {
+    const flags = body[offset]!
+    const length = new DataView(body.buffer, body.byteOffset + offset + 1, 4).getUint32(0, false)
+    offset += 5
+    if (offset + length > body.byteLength) break
+    const frame = body.subarray(offset, offset + length)
+    offset += length
+    const isTrailer = (flags & 0x80) === 0x80
+    if (isTrailer) {
+      trailers = { ...trailers, ...parseGrpcWebTrailers(frame) }
+    } else if (message == null) {
+      message = frame
+    }
+  }
+  return { message, trailers }
+}
+
+function joinUrl(baseUrl: string, path: string): string {
+  return baseUrl.replace(/\/+$/, '') + '/' + path.replace(/^\/+/, '')
+}
+
+function capitalizeRpcName(methodName: string): string {
+  if (!methodName) return methodName
+  return methodName[0]!.toUpperCase() + methodName.slice(1)
+}
+
+function getGrpcWebPath(service: any, methodName: string, method: any): string {
+  const typeName = String(service?.typeName ?? '')
+  const rpcName = String(method?.name ?? method?.rpc?.name ?? '') || capitalizeRpcName(methodName)
+  return `${typeName}/${rpcName}`
+}
+
+async function rnGrpcWebUnary(args: {
+  baseUrl: string
+  service: any
+  methodName: string
+  method?: any
+  request: any
+  headers: Record<string, string>
+  callOptions?: { timeoutMs?: number }
+}): Promise<any> {
+  const method =
+    args.method ??
+    (() => {
+      const ms = args.service?.methods
+      if (Array.isArray(ms)) return ms.find((m: any) => m?.localName === args.methodName || m?.name === args.methodName)
+      if (ms && typeof ms === 'object') return (ms as any)[args.methodName]
+      return undefined
+    })()
+  if (!method) {
+    throw new Error(`gRPC method not found: ${String(args.service?.typeName ?? '')}.${args.methodName}`)
+  }
+
+  const url = joinUrl(args.baseUrl, getGrpcWebPath(args.service, args.methodName, method))
+  const contentType = 'application/grpc-web+proto'
+
+  if (!method.input || !method.output) {
+    throw new Error(`gRPC method schema missing: ${String(args.service?.typeName ?? '')}.${args.methodName}`)
+  }
+  const requestBytes = toBinary(method.input, args.request)
+  const body = grpcWebEncodeUnary(requestBytes)
+
+  const controller = new AbortController()
+  const timeoutMs = args.callOptions?.timeoutMs
+  const timeoutId = timeoutMs ? setTimeout(() => controller.abort(), timeoutMs) : undefined
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      ...args.headers,
+      'content-type': contentType,
+      accept: contentType,
+      'x-grpc-web': '1',
+    },
+    body,
+    signal: controller.signal,
+  })
+  try {
+    if (!res.ok) {
+      throw new Error(`gRPC fetch failed: ${res.status} ${res.statusText}`)
+    }
+    const raw = new Uint8Array(await res.arrayBuffer())
+    const decoded = grpcWebDecodeUnary(raw)
+    const grpcStatus = decoded.trailers['grpc-status'] ?? '0'
+    if (grpcStatus !== '0') {
+      const msg = decoded.trailers['grpc-message'] ?? 'gRPC request failed'
+      throw new Error(`gRPC status=${grpcStatus} message=${msg}`)
+    }
+    if (!decoded.message) throw new Error('gRPC response message missing')
+    return fromBinary(method.output, decoded.message)
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId)
+  }
+}
+
+const rnGrpcInvoker = { unary: rnGrpcWebUnary }
+
+const sdk = initSDK({
+  ws: {
+    url: 'wss://example.com/websocket',
+    protocols: fetchGuid(),
+  },
+  grpc: {
+    baseUrl: 'https://example.com/cms',
+    protocol: 'grpc-web',
+    invoker: rnGrpcInvoker,
+  },
+  http: {
+    baseUrl: 'https://example.com/api',
+  },
+  headerConfig: {
+    version: '1.0.0',
+    platformId: '50',
+    isReload: false,
+    deviceType: 1,
+    deviceId: '',
+    childPlatformId: '50',
+  },
+  defaultTransport: 'auto',
+})
+```
+
+补充说明：如果你已经在 RN 工程里有基于 `@improbable-eng/grpc-web` / `@improbable-eng/grpc-web-react-native-transport` 的 `rnGrpcWebUnary` 封装，也可以直接把它塞进 `invoker.unary`。但需要确保它能消费本 SDK 生成的 bufbuild message 与 schema（`toBinary/fromBinary`），否则通常会因为“message/descriptor 体系不一致”（improbable 常见搭配是另一套 proto 生成物）而对不上类型与序列化方式。
+
 ### 2) 直接调用（推荐）
 
 优先使用 service client（类型提示完整，第二参随 transport 自动变化）：

package/dist/index.cjs

@@ -186,13 +186,52 @@ var GrpcClient = class {
   getInvokerClientKey(service, baseUrl) {
     return `${String(service?.typeName ?? "")}@@${baseUrl}`;
   }
+  getServiceMethodMap(service) {
+    const out = {};
+    const addMethod = (m) => {
+      if (!m) return;
+      const localName = m.localName != null ? String(m.localName) : "";
+      const name = m.name != null ? String(m.name) : "";
+      if (localName) out[localName] = m;
+      if (name && !(name in out)) out[name] = m;
+    };
+    const direct = service?.method;
+    if (direct && typeof direct === "object") {
+      for (const [k, v] of Object.entries(direct)) {
+        if (v) out[k] = v;
+        addMethod(v);
+      }
+    }
+    const methods = service?.methods;
+    if (Array.isArray(methods)) {
+      for (const m of methods) addMethod(m);
+    } else if (methods && typeof methods === "object") {
+      for (const [k, v] of Object.entries(methods)) {
+        if (v) out[k] = v;
+        addMethod(v);
+      }
+    }
+    return Object.keys(out).length > 0 ? out : void 0;
+  }
+  getServiceMethodDesc(service, methodName) {
+    const methodMap = this.getServiceMethodMap(service);
+    if (!methodMap) return void 0;
+    const direct = methodMap[methodName];
+    if (direct) return direct;
+    for (const m of Object.values(methodMap)) {
+      if (!m) continue;
+      const localName = m.localName != null ? String(m.localName) : "";
+      const name = m.name != null ? String(m.name) : "";
+      if (localName === methodName || name === methodName) return m;
+    }
+    return void 0;
+  }
   getServiceViaInvoker(service) {
     const baseUrl = this.pickBaseUrl(service.typeName ?? "");
     const key = this.getInvokerClientKey(service, baseUrl);
     const cached = this.invokerClientByKey.get(key);
     if (cached) return cached;
-    const methods = service?.methods;
-    const hasMethodsMap = methods && typeof methods === "object";
+    const methodMap = this.getServiceMethodMap(service);
     const typeName = String(service?.typeName ?? "");
     const client = new Proxy(
       {},
@@ -200,7 +239,7 @@ var GrpcClient = class {
         get: (_target, prop) => {
           if (prop === "then") return void 0;
           if (typeof prop !== "string") return void 0;
-          if (hasMethodsMap && !(prop in methods)) {
+          if (methodMap && !(prop in methodMap)) {
             return async () => {
               throw new Error(`gRPC method not found: ${typeName}.${prop}`);
             };
@@ -219,6 +258,7 @@ var GrpcClient = class {
     const baseUrl = this.pickBaseUrl(typeName);
     try {
       if (this.invoker) {
+        const method2 = this.getServiceMethodDesc(service, methodName);
         const headers = await this.attachInvokerHeaders(
           this.normalizeHeaders(options?.headers),
           methodName
@@ -233,6 +273,7 @@ var GrpcClient = class {
           baseUrl,
           service,
           methodName,
+          method: method2,
           request,
           headers,
           callOptions: options