# 安装 buf 工具
# https://buf.build/docs/installation
go install github.com/bufbuild/buf/cmd/buf@latest

# 安装 connect-go
go get connectrpc.com/connect

# 安装 protoc-gen-connect-go
go install connectrpc.com/connect/cmd/protoc-gen-connect-go@latest

# buf.yaml
version: v1
breaking:
  use:
    - FILE
lint:
  use:
    - DEFAULT

# buf.gen.yaml
version: v1
plugins:
  - plugin: buf.build/protocolbuffers/go
    out: gen
    opt: paths=source_relative
  - plugin: buf.build/connectrpc/go
    out: gen
    opt: paths=source_relative

// user/v1/user.proto
syntax = "proto3";

package user.v1;

message User {
  int64 id = 1;
  string name = 2;
  string email = 3;
}

message GetUserRequest {
  int64 id = 1;
}

message GetUserResponse {
  User user = 1;
}

message ListUsersRequest {
  int32 page_size = 1;
  string page_token = 2;
}

message ListUsersResponse {
  repeated User users = 1;
  string next_page_token = 2;
}

// user/v1/user_service.proto
syntax = "proto3";

package user.v1;

import "user/v1/user.proto";

service UserService {
  rpc GetUser(GetUserRequest) returns (GetUserResponse);
  rpc ListUsers(ListUsersRequest) returns (stream User);
}

# 生成代码
buf generate

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"

	userv1 "example/gen/user/v1"
	"example/gen/user/v1/userv1connect"

	"connectrpc.com/connect"
	"golang.org/x/net/http2"
	"golang.org/x/net/http2/h2c"
)

type userServer struct {
	userv1connect.UnimplementedUserServiceHandler
	users map[int64]*userv1.User
}

func newUserServer() *userServer {
	return &userServer{
		users: map[int64]*userv1.User{
			1: {Id: 1, Name: "Alice", Email: "[email protected]"},
			2: {Id: 2, Name: "Bob", Email: "[email protected]"},
		},
	}
}

func (s *userServer) GetUser(
	ctx context.Context,
	req *connect.Request[userv1.GetUserRequest],
) (*connect.Response[userv1.GetUserResponse], error) {
	user, ok := s.users[req.Msg.Id]
	if !ok {
		return nil, connect.NewError(connect.CodeNotFound,
			fmt.Errorf("用户 %d 不存在", req.Msg.Id))
	}

	resp := connect.NewResponse(&userv1.GetUserResponse{User: user})
	resp.Header().Set("X-Request-Id", "req-123")
	return resp, nil
}

func (s *userServer) ListUsers(
	ctx context.Context,
	req *connect.Request[userv1.ListUsersRequest],
	stream *connect.ServerStream[userv1.User],
) error {
	for _, user := range s.users {
		if err := stream.Send(user); err != nil {
			return err
		}
	}
	return nil
}

func main() {
	server := newUserServer()
	mux := http.NewServeMux()

	// 注册 Connect 服务
	path, handler := userv1connect.NewUserServiceHandler(server)
	mux.Handle(path, handler)

	// 同时支持 HTTP/2 和 HTTP/1.1（h2c 用于开发，生产环境用 TLS）
	addr := ":8080"
	log.Printf("Connect 服务器启动于 %s", addr)
	log.Printf("  Connect 协议: POST http://%s/user.v1.UserService/GetUser", addr)
	log.Printf("  gRPC 协议:    POST http://%s/user.v1.UserService/GetUser (gRPC headers)", addr)
	
	http.ListenAndServe(addr, h2c.NewHandler(mux, &http2.Server{}))
}

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"

	userv1 "example/gen/user/v1"
	"example/gen/user/v1/userv1connect"

	"connectrpc.com/connect"
)

func main() {
	// 创建 Connect 客户端
	client := userv1connect.NewUserServiceClient(
		http.DefaultClient,
		"http://localhost:8080",
	)

	// Unary 调用
	resp, err := client.GetUser(
		context.Background(),
		connect.NewRequest(&userv1.GetUserRequest{Id: 1}),
	)
	if err != nil {
		log.Printf("调用失败: %v", err)
		if connectErr, ok := err.(*connect.Error); ok {
			log.Printf("错误码: %s, 消息: %s", connectErr.Code(), connectErr.Message())
		}
		return
	}
	fmt.Printf("用户: %s (%s)\n", resp.Msg.User.Name, resp.Msg.User.Email)

	// 流式调用
	stream, err := client.ListUsers(
		context.Background(),
		connect.NewRequest(&userv1.ListUsersRequest{PageSize: 100}),
	)
	if err != nil {
		log.Fatalf("流式调用失败: %v", err)
	}
	for stream.Receive() {
		user := stream.Msg()
		fmt.Printf("  流式接收: %s\n", user.Name)
	}
	if err := stream.Err(); err != nil {
		log.Fatalf("流错误: %v", err)
	}
}

// 使用 @connectrpc/connect-web
import { createClient } from "@connectrpc/connect";
import { createConnectTransport } from "@connectrpc/connect-web";
import { UserService } from "./gen/user/v1/user_service_pb";

// 创建传输层（Connect 协议，支持 HTTP/1.1）
const transport = createConnectTransport({
  baseUrl: "http://localhost:8080",
});

// 创建客户端
const client = createClient(UserService, transport);

// 调用
async function getUser(id: bigint) {
  try {
    const response = await client.getUser({ id });
    console.log(`用户: ${response.user?.name}`);
  } catch (err) {
    console.error("调用失败:", err);
  }
}

// 流式调用（服务端流）
async function listUsers() {
  for await (const user of client.listUsers({ pageSize: 100 })) {
    console.log(`用户: ${user.name}`);
  }
}

# Connect 协议 + JSON 编码（curl 友好！）
curl \
  --header "Content-Type: application/json" \
  --data '{"id": 1}' \
  http://localhost:8080/user.v1.UserService/GetUser

# 输出：
# {"user": {"id": "1", "name": "Alice", "email": "[email protected]"}}

# 对比 gRPC（需要 grpcurl）
# grpcurl -plaintext -d '{"id": 1}' localhost:50051 user.v1.UserService/GetUser

{
  "code": "not_found",
  "message": "用户 123 不存在",
  "details": [
    {
      "type": "google.rpc.ErrorInfo",
      "value": "eyJkb21haW4iOiJ1c2VyIn0=",
      "debug": {
        "reason": "USER_NOT_FOUND",
        "domain": "user-service",
        "metadata": {"user_id": "123"}
      }
    }
  ]
}

package main

import (
	"context"
	"log"
	"time"

	"connectrpc.com/connect"
)

// 日志拦截器
func loggingInterceptor() connect.UnaryInterceptorFunc {
	return func(next connect.UnaryFunc) connect.UnaryFunc {
		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
			start := time.Now()
			log.Printf("[Connect] %s %s", req.Spec().Procedure, "START")

			resp, err := next(ctx, req)

			log.Printf("[Connect] %s duration=%v err=%v",
				req.Spec().Procedure, time.Since(start), err)
			return resp, err
		}
	}
}

// 认证拦截器
func authInterceptor() connect.UnaryInterceptorFunc {
	return func(next connect.UnaryFunc) connect.UnaryFunc {
		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
			// 从 HTTP Header 获取 token
			token := req.Header().Get("Authorization")
			if token == "" {
				return nil, connect.NewError(connect.CodeUnauthenticated,
					fmt.Errorf("缺少认证信息"))
			}

			// 验证 token
			if err := validateToken(token); err != nil {
				return nil, connect.NewError(connect.CodeUnauthenticated, err)
			}

			return next(ctx, req)
		}
	}
}

// 使用拦截器
func main() {
	mux := http.NewServeMux()

	// 服务端拦截器
	path, handler := userv1connect.NewUserServiceHandler(
		newUserServer(),
		connect.WithInterceptors(loggingInterceptor(), authInterceptor()),
	)
	mux.Handle(path, handler)

	// 客户端拦截器
	client := userv1connect.NewUserServiceClient(
		http.DefaultClient,
		"http://localhost:8080",
		connect.WithInterceptors(loggingInterceptor()),
	)
	_ = client
}