// user.proto — スキーマ定義
syntax = "proto3";
 
package user.v1;
 
// Go のパッケージパス指定
option go_package = "github.com/example/user/v1;userv1";
// Java のパッケージ指定
option java_package = "com.example.user.v1";
option java_multiple_files = true;
 
// メッセージ定義（データ構造）
message User {
  string id = 1;         // フィールド番号（バイナリ識別子）
  string name = 2;
  string email = 3;
  int32 age = 4;
  repeated string roles = 5;  // 配列
  Address address = 6;        // ネストされたメッセージ
  optional string phone = 7;  // オプショナル
 
  // enum定義
  UserStatus status = 8;
 
  // タイムスタンプ型（Well-Known Types）
  google.protobuf.Timestamp created_at = 9;
  google.protobuf.Timestamp updated_at = 10;
 
  // マップ型
  map<string, string> metadata = 11;
 
  // oneof（排他的フィールド）
  oneof notification_preference {
    EmailPreference email_pref = 12;
    SmsPreference sms_pref = 13;
    PushPreference push_pref = 14;
  }
}
 
// Enum定義
enum UserStatus {
  USER_STATUS_UNSPECIFIED = 0;  // デフォルト値（必須）
  USER_STATUS_ACTIVE = 1;
  USER_STATUS_INACTIVE = 2;
  USER_STATUS_SUSPENDED = 3;
  USER_STATUS_DELETED = 4;
}
 
message EmailPreference {
  bool daily_digest = 1;
  bool weekly_summary = 2;
}
 
message SmsPreference {
  string phone_number = 1;
  bool urgent_only = 2;
}
 
message PushPreference {
  string device_token = 1;
  repeated string topics = 2;
}
 
message Address {
  string street = 1;
  string city = 2;
  string state = 3;
  string country = 4;
  string zip_code = 5;
  double latitude = 6;
  double longitude = 7;
}
 
// Well-Known Typesのインポート
import "google/protobuf/timestamp.proto";
import "google/protobuf/duration.proto";
import "google/protobuf/empty.proto";
import "google/protobuf/field_mask.proto";
import "google/protobuf/wrappers.proto";
import "google/protobuf/any.proto";
import "google/protobuf/struct.proto";
 
// サービス定義（RPC）
service UserService {
  // Unary: 1リクエスト → 1レスポンス
  rpc GetUser(GetUserRequest) returns (GetUserResponse);
  rpc CreateUser(CreateUserRequest) returns (CreateUserResponse);
  rpc UpdateUser(UpdateUserRequest) returns (UpdateUserResponse);
  rpc DeleteUser(DeleteUserRequest) returns (google.protobuf.Empty);
 
  // Server Streaming: 1リクエスト → 複数レスポンス
  rpc ListUsers(ListUsersRequest) returns (stream User);
  rpc WatchUserUpdates(WatchUserUpdatesRequest) returns (stream UserEvent);
 
  // Client Streaming: 複数リクエスト → 1レスポンス
  rpc UploadUsers(stream User) returns (UploadUsersResponse);
  rpc BatchCreateUsers(stream CreateUserRequest) returns (BatchCreateUsersResponse);
 
  // Bidirectional Streaming: 双方向ストリーム
  rpc Chat(stream ChatMessage) returns (stream ChatMessage);
  rpc SyncUsers(stream UserSyncRequest) returns (stream UserSyncResponse);
}
 
message GetUserRequest {
  string id = 1;
  // FieldMask で返却フィールドを制御
  google.protobuf.FieldMask field_mask = 2;
}
 
message GetUserResponse {
  User user = 1;
}
 
message CreateUserRequest {
  string name = 1;
  string email = 2;
  int32 age = 3;
  repeated string roles = 4;
  Address address = 5;
}
 
message CreateUserResponse {
  User user = 1;
}
 
message UpdateUserRequest {
  string id = 1;
  User user = 2;
  // FieldMask で更新するフィールドを指定（部分更新）
  google.protobuf.FieldMask update_mask = 3;
}
 
message UpdateUserResponse {
  User user = 1;
}
 
message DeleteUserRequest {
  string id = 1;
}
 
message ListUsersRequest {
  int32 page_size = 1;
  string page_token = 2;
  string filter = 3;     // フィルタリング条件
  string order_by = 4;   // ソート条件
}
 
message UploadUsersResponse {
  int32 count = 1;
  repeated string failed_ids = 2;
}
 
message BatchCreateUsersResponse {
  int32 success_count = 1;
  int32 failure_count = 2;
  repeated BatchError errors = 3;
}
 
message BatchError {
  int32 index = 1;
  string message = 2;
  int32 code = 3;
}
 
message WatchUserUpdatesRequest {
  repeated string user_ids = 1;
  repeated string event_types = 2;
}
 
message UserEvent {
  string event_type = 1;  // "created", "updated", "deleted"
  User user = 2;
  google.protobuf.Timestamp timestamp = 3;
}
 
message ChatMessage {
  string from = 1;
  string text = 2;
  int64 timestamp = 3;
  string room_id = 4;
}
 
message UserSyncRequest {
  string operation = 1;
  User user = 2;
  string client_id = 3;
}
 
message UserSyncResponse {
  string operation = 1;
  User user = 2;
  bool conflict = 3;
  User resolved_user = 4;
}

// === フィールド番号の管理 ===
 
// フィールド番号のルール:
// 1-15: 1バイトでエンコード → 頻出フィールドに使用
// 16-2047: 2バイトでエンコード
// 2048-: 3バイト以上
// 19000-19999: 予約済み（使用不可）
 
message OptimizedMessage {
  // 頻出フィールドに1-15を割り当て
  string id = 1;
  string name = 2;
  int32 status = 3;
 
  // あまり使わないフィールドは16以降
  string description = 16;
  map<string, string> metadata = 17;
  repeated string tags = 18;
}
 
// === 後方互換性の維持 ===
 
// 安全な変更:
// ✓ フィールドの追加（新しい番号で）
// ✓ フィールドの削除（番号を予約して）
// ✓ フィールド名の変更（番号が同じなら）
// ✓ optional ↔ repeated（互換性あり）
 
// 破壊的変更（絶対に避ける）:
// ✗ フィールド番号の変更
// ✗ フィールドの型変更（int32 → string等）
// ✗ 削除したフィールド番号の再利用
 
message UserV2 {
  string id = 1;
  string full_name = 2;  // 名前変更OK（番号同じ）
  string email = 3;
 
  // フィールド4,5は過去に使用済み → 予約
  reserved 4, 5;
  reserved "age", "phone";
 
  // 新しいフィールドは新しい番号で
  string display_name = 6;
  UserProfile profile = 7;
}
 
// === パッケージのバージョニング ===
 
// APIバージョンをパッケージに含める
// package company.service.v1;
// package company.service.v2;
 
// ファイル構造:
// proto/
//   user/
//     v1/
//       user.proto
//       user_service.proto
//     v2/
//       user.proto
//       user_service.proto

// === プロジェクトセットアップ ===
// package.json の依存関係:
// "@grpc/grpc-js": "^1.9.0"
// "@grpc/proto-loader": "^0.7.0"
// "google-protobuf": "^3.21.0"
 
// === 方法1: 動的ロード（開発向け） ===
// server.ts
import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
import { v4 as uuidv4 } from 'uuid';
 
// Proto定義のロード
const packageDef = protoLoader.loadSync('proto/user/v1/user_service.proto', {
  keepCase: true,         // フィールド名をsnake_caseのまま
  longs: String,          // int64をstringに変換
  enums: String,          // enumをstringに変換
  defaults: true,         // デフォルト値を含める
  oneofs: true,           // oneofフィールドを含める
  includeDirs: ['proto'], // インポートパスの検索ディレクトリ
});
 
const proto = grpc.loadPackageDefinition(packageDef) as any;
 
// インメモリデータストア（デモ用）
const users = new Map<string, any>();
 
// === Unary RPC 実装 ===
function getUser(
  call: grpc.ServerUnaryCall<any, any>,
  callback: grpc.sendUnaryData<any>,
): void {
  const userId = call.request.id;
 
  // メタデータからの情報取得
  const metadata = call.metadata;
  const requestId = metadata.get('x-request-id')[0] || uuidv4();
  const authToken = metadata.get('authorization')[0];
 
  console.log(`[${requestId}] GetUser called for id: ${userId}`);
 
  // 認証チェック
  if (!authToken) {
    callback({
      code: grpc.status.UNAUTHENTICATED,
      message: 'Authentication token is required',
      metadata: createErrorMetadata(requestId),
    });
    return;
  }
 
  const user = users.get(userId);
 
  if (!user) {
    callback({
      code: grpc.status.NOT_FOUND,
      message: `User ${userId} not found`,
      metadata: createErrorMetadata(requestId),
    });
    return;
  }
 
  // FieldMask対応（指定されたフィールドのみ返却）
  const fieldMask = call.request.field_mask;
  if (fieldMask && fieldMask.paths.length > 0) {
    const filteredUser = filterByFieldMask(user, fieldMask.paths);
    callback(null, { user: filteredUser });
  } else {
    callback(null, { user });
  }
}
 
// === CreateUser 実装 ===
function createUser(
  call: grpc.ServerUnaryCall<any, any>,
  callback: grpc.sendUnaryData<any>,
): void {
  const { name, email, age, roles, address } = call.request;
 
  // バリデーション
  const errors: string[] = [];
  if (!name || name.trim().length === 0) {
    errors.push('name is required');
  }
  if (!email || !email.includes('@')) {
    errors.push('valid email is required');
  }
  if (age !== undefined && (age < 0 || age > 150)) {
    errors.push('age must be between 0 and 150');
  }
 
  if (errors.length > 0) {
    callback({
      code: grpc.status.INVALID_ARGUMENT,
      message: `Validation failed: ${errors.join(', ')}`,
    });
    return;
  }
 
  // メール重複チェック
  for (const [, existingUser] of users) {
    if (existingUser.email === email) {
      callback({
        code: grpc.status.ALREADY_EXISTS,
        message: `User with email ${email} already exists`,
      });
      return;
    }
  }
 
  const user = {
    id: uuidv4(),
    name,
    email,
    age: age || 0,
    roles: roles || [],
    address: address || null,
    status: 'USER_STATUS_ACTIVE',
    created_at: { seconds: Math.floor(Date.now() / 1000), nanos: 0 },
    updated_at: { seconds: Math.floor(Date.now() / 1000), nanos: 0 },
    metadata: {},
  };
 
  users.set(user.id, user);
  console.log(`User created: ${user.id}`);
 
  callback(null, { user });
}
 
// === UpdateUser 実装（FieldMask対応の部分更新） ===
function updateUser(
  call: grpc.ServerUnaryCall<any, any>,
  callback: grpc.sendUnaryData<any>,
): void {
  const { id, user: updateData, update_mask } = call.request;
 
  const existingUser = users.get(id);
  if (!existingUser) {
    callback({
      code: grpc.status.NOT_FOUND,
      message: `User ${id} not found`,
    });
    return;
  }
 
  // FieldMaskに基づいた部分更新
  if (update_mask && update_mask.paths.length > 0) {
    for (const path of update_mask.paths) {
      if (path in updateData) {
        existingUser[path] = updateData[path];
      }
    }
  } else {
    // FieldMaskがない場合は全フィールド更新
    Object.assign(existingUser, updateData, { id });
  }
 
  existingUser.updated_at = {
    seconds: Math.floor(Date.now() / 1000),
    nanos: 0,
  };
 
  users.set(id, existingUser);
  callback(null, { user: existingUser });
}
 
// === Server Streaming 実装 ===
function listUsers(call: grpc.ServerWritableStream<any, any>): void {
  const { page_size, filter, order_by } = call.request;
  const limit = page_size || 100;
 
  let userList = Array.from(users.values());
 
  // フィルタリング
  if (filter) {
    userList = applyFilter(userList, filter);
  }
 
  // ソート
  if (order_by) {
    userList = applySort(userList, order_by);
  }
 
  // ページサイズに制限
  userList = userList.slice(0, limit);
 
  // ストリームで1件ずつ送信
  let index = 0;
  const sendNext = () => {
    if (index < userList.length) {
      const canWrite = call.write(userList[index]);
      index++;
 
      if (canWrite) {
        // すぐに次を送信
        setImmediate(sendNext);
      } else {
        // バックプレッシャー: drain イベントを待つ
        call.once('drain', sendNext);
      }
    } else {
      call.end();
    }
  };
 
  sendNext();
 
  // クライアントのキャンセルを監視
  call.on('cancelled', () => {
    console.log('ListUsers stream cancelled by client');
  });
}
 
// === Client Streaming 実装 ===
function uploadUsers(
  call: grpc.ServerReadableStream<any, any>,
  callback: grpc.sendUnaryData<any>,
): void {
  let count = 0;
  const failedIds: string[] = [];
 
  call.on('data', (user: any) => {
    try {
      // バリデーションとストア
      if (!user.name || !user.email) {
        failedIds.push(user.id || 'unknown');
        return;
      }
 
      const id = user.id || uuidv4();
      users.set(id, { ...user, id });
      count++;
    } catch (error) {
      failedIds.push(user.id || 'unknown');
    }
  });
 
  call.on('end', () => {
    callback(null, {
      count,
      failed_ids: failedIds,
    });
  });
 
  call.on('error', (error: Error) => {
    console.error('Upload stream error:', error);
    callback({
      code: grpc.status.INTERNAL,
      message: `Stream error: ${error.message}`,
    });
  });
}
 
// === Bidirectional Streaming 実装 ===
function chat(call: grpc.ServerDuplexStream<any, any>): void {
  const roomId = call.metadata.get('room-id')[0] as string || 'default';
  console.log(`Chat stream opened for room: ${roomId}`);
 
  call.on('data', (message: any) => {
    console.log(`[${roomId}] ${message.from}: ${message.text}`);
 
    // エコーバック（実際にはブロードキャスト）
    call.write({
      from: 'server',
      text: `Received: ${message.text}`,
      timestamp: Date.now(),
      room_id: roomId,
    });
 
    // ボットレスポンス（デモ用）
    if (message.text.toLowerCase().includes('hello')) {
      call.write({
        from: 'bot',
        text: `Hello, ${message.from}! Welcome to room ${roomId}.`,
        timestamp: Date.now(),
        room_id: roomId,
      });
    }
  });
 
  call.on('end', () => {
    console.log(`Chat stream closed for room: ${roomId}`);
    call.end();
  });
 
  call.on('error', (error: Error) => {
    console.error(`Chat stream error in room ${roomId}:`, error);
  });
 
  call.on('cancelled', () => {
    console.log(`Chat stream cancelled for room: ${roomId}`);
  });
}
 
// === ヘルパー関数 ===
function createErrorMetadata(requestId: string): grpc.Metadata {
  const metadata = new grpc.Metadata();
  metadata.set('x-request-id', requestId);
  return metadata;
}
 
function filterByFieldMask(obj: any, paths: string[]): any {
  const result: any = {};
  for (const path of paths) {
    if (path in obj) {
      result[path] = obj[path];
    }
  }
  return result;
}
 
function applyFilter(users: any[], filter: string): any[] {
  // シンプルなフィルタ実装（例: "status=active"）
  const [key, value] = filter.split('=');
  return users.filter(u => String(u[key]) === value);
}
 
function applySort(users: any[], orderBy: string): any[] {
  const desc = orderBy.startsWith('-');
  const field = desc ? orderBy.slice(1) : orderBy;
  return users.sort((a, b) => {
    const cmp = a[field] < b[field] ? -1 : a[field] > b[field] ? 1 : 0;
    return desc ? -cmp : cmp;
  });
}
 
// === サーバー起動 ===
function startServer(): void {
  const server = new grpc.Server({
    // サーバー設定
    'grpc.max_receive_message_length': 10 * 1024 * 1024, // 10MB
    'grpc.max_send_message_length': 10 * 1024 * 1024,    // 10MB
    'grpc.keepalive_time_ms': 60000,                      // 60秒
    'grpc.keepalive_timeout_ms': 20000,                   // 20秒
    'grpc.keepalive_permit_without_calls': 1,             // コールなしでもKeepalive
  });
 
  server.addService(proto.user.v1.UserService.service, {
    getUser,
    createUser,
    updateUser,
    listUsers,
    uploadUsers,
    chat,
  });
 
  const address = '0.0.0.0:50051';
 
  server.bindAsync(
    address,
    grpc.ServerCredentials.createInsecure(),
    (error, port) => {
      if (error) {
        console.error('Server bind error:', error);
        process.exit(1);
      }
      console.log(`gRPC server listening on port ${port}`);
    },
  );
 
  // グレースフルシャットダウン
  process.on('SIGTERM', () => {
    console.log('Received SIGTERM, shutting down gracefully...');
    server.tryShutdown((error) => {
      if (error) {
        console.error('Error during shutdown:', error);
        server.forceShutdown();
      }
      console.log('Server shut down successfully');
      process.exit(0);
    });
  });
}
 
startServer();

// client.ts
import * as grpc from '@grpc/grpc-js';
import * as protoLoader from '@grpc/proto-loader';
 
const packageDef = protoLoader.loadSync('proto/user/v1/user_service.proto', {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
  includeDirs: ['proto'],
});
 
const proto = grpc.loadPackageDefinition(packageDef) as any;
 
// === クライアント作成 ===
function createClient(address: string = 'localhost:50051') {
  const client = new proto.user.v1.UserService(
    address,
    grpc.credentials.createInsecure(),
    {
      // クライアント設定
      'grpc.keepalive_time_ms': 30000,
      'grpc.keepalive_timeout_ms': 10000,
      'grpc.max_receive_message_length': 10 * 1024 * 1024,
      'grpc.initial_reconnect_backoff_ms': 1000,
      'grpc.max_reconnect_backoff_ms': 30000,
    },
  );
 
  return client;
}
 
// === Unary RPCの呼び出し ===
async function getUser(
  client: any,
  userId: string,
): Promise<any> {
  return new Promise((resolve, reject) => {
    // メタデータの設定
    const metadata = new grpc.Metadata();
    metadata.set('authorization', 'Bearer my-token');
    metadata.set('x-request-id', generateRequestId());
 
    // デッドライン（タイムアウト）の設定
    const deadline = new Date();
    deadline.setSeconds(deadline.getSeconds() + 5); // 5秒タイムアウト
 
    client.getUser(
      { id: userId, field_mask: { paths: ['name', 'email'] } },
      metadata,
      { deadline },
      (error: grpc.ServiceError | null, response: any) => {
        if (error) {
          handleGrpcError(error);
          reject(error);
          return;
        }
        resolve(response.user);
      },
    );
  });
}
 
// === Server Streaming の呼び出し ===
async function listAllUsers(client: any): Promise<any[]> {
  return new Promise((resolve, reject) => {
    const users: any[] = [];
 
    const metadata = new grpc.Metadata();
    metadata.set('authorization', 'Bearer my-token');
 
    const call = client.listUsers(
      { page_size: 100, filter: 'status=USER_STATUS_ACTIVE' },
      metadata,
    );
 
    call.on('data', (user: any) => {
      users.push(user);
      console.log(`Received user: ${user.name}`);
    });
 
    call.on('end', () => {
      console.log(`Total users received: ${users.length}`);
      resolve(users);
    });
 
    call.on('error', (error: grpc.ServiceError) => {
      handleGrpcError(error);
      reject(error);
    });
 
    call.on('status', (status: grpc.StatusObject) => {
      console.log(`Stream status: ${status.code} - ${status.details}`);
    });
 
    // 10秒後にキャンセル（タイムアウト）
    setTimeout(() => {
      call.cancel();
    }, 10000);
  });
}
 
// === Client Streaming の呼び出し ===
async function batchUploadUsers(
  client: any,
  userList: any[],
): Promise<any> {
  return new Promise((resolve, reject) => {
    const metadata = new grpc.Metadata();
    metadata.set('authorization', 'Bearer my-token');
 
    const call = client.uploadUsers(
      metadata,
      (error: grpc.ServiceError | null, response: any) => {
        if (error) {
          handleGrpcError(error);
          reject(error);
          return;
        }
        console.log(`Uploaded ${response.count} users`);
        resolve(response);
      },
    );
 
    // ユーザーを1件ずつストリーム送信
    for (const user of userList) {
      call.write(user);
    }
 
    // ストリーム終了
    call.end();
  });
}
 
// === Bidirectional Streaming の呼び出し ===
async function startChat(
  client: any,
  userName: string,
  roomId: string,
): Promise<void> {
  const metadata = new grpc.Metadata();
  metadata.set('authorization', 'Bearer my-token');
  metadata.set('room-id', roomId);
 
  const call = client.chat(metadata);
 
  // サーバーからのメッセージ受信
  call.on('data', (message: any) => {
    console.log(`[${message.from}]: ${message.text}`);
  });
 
  call.on('end', () => {
    console.log('Chat stream ended');
  });
 
  call.on('error', (error: grpc.ServiceError) => {
    if (error.code !== grpc.status.CANCELLED) {
      handleGrpcError(error);
    }
  });
 
  // メッセージ送信
  call.write({
    from: userName,
    text: 'Hello everyone!',
    timestamp: Date.now(),
    room_id: roomId,
  });
 
  // 定期的にメッセージ送信（デモ用）
  const interval = setInterval(() => {
    call.write({
      from: userName,
      text: `Ping at ${new Date().toISOString()}`,
      timestamp: Date.now(),
      room_id: roomId,
    });
  }, 5000);
 
  // 30秒後にチャット終了
  setTimeout(() => {
    clearInterval(interval);
    call.end();
  }, 30000);
}
 
// === エラーハンドリング ===
function handleGrpcError(error: grpc.ServiceError): void {
  const statusName = Object.keys(grpc.status).find(
    key => grpc.status[key as keyof typeof grpc.status] === error.code,
  );
 
  console.error(`gRPC Error [${statusName}] (${error.code}): ${error.message}`);
 
  // メタデータの詳細を表示
  if (error.metadata) {
    const requestId = error.metadata.get('x-request-id');
    if (requestId.length > 0) {
      console.error(`  Request ID: ${requestId[0]}`);
    }
  }
 
  // エラーコードに応じた処理
  switch (error.code) {
    case grpc.status.UNAVAILABLE:
      console.error('  → Service is unavailable. Retry with backoff.');
      break;
    case grpc.status.DEADLINE_EXCEEDED:
      console.error('  → Request timed out. Consider increasing deadline.');
      break;
    case grpc.status.UNAUTHENTICATED:
      console.error('  → Authentication failed. Check credentials.');
      break;
    case grpc.status.PERMISSION_DENIED:
      console.error('  → Permission denied. Check authorization.');
      break;
    case grpc.status.RESOURCE_EXHAUSTED:
      console.error('  → Rate limited. Back off and retry.');
      break;
    case grpc.status.NOT_FOUND:
      console.error('  → Resource not found.');
      break;
    default:
      console.error('  → Unexpected error.');
  }
}
 
function generateRequestId(): string {
  return `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
}
 
// === メイン実行 ===
async function main(): Promise<void> {
  const client = createClient();
 
  try {
    // ユーザー作成
    const created = await new Promise<any>((resolve, reject) => {
      client.createUser(
        { name: 'Taro', email: 'taro@example.com', age: 25 },
        (err: any, res: any) => err ? reject(err) : resolve(res),
      );
    });
    console.log('Created:', created.user);
 
    // ユーザー取得
    const user = await getUser(client, created.user.id);
    console.log('Got:', user);
 
    // ユーザー一覧（ストリーミング）
    const allUsers = await listAllUsers(client);
    console.log('All users:', allUsers);
 
  } catch (error) {
    console.error('Error:', error);
  } finally {
    client.close();
  }
}
 
main();

// === サーバー側（Go） ===
// server/main.go
package main
 
import (
	"context"
	"fmt"
	"io"
	"log"
	"net"
	"sync"
	"time"
 
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/emptypb"
	"google.golang.org/protobuf/types/known/timestamppb"
 
	pb "github.com/example/user/v1"
)
 
type userServer struct {
	pb.UnimplementedUserServiceServer
	mu    sync.RWMutex
	users map[string]*pb.User
}
 
func newUserServer() *userServer {
	return &userServer{
		users: make(map[string]*pb.User),
	}
}
 
// Unary RPC
func (s *userServer) GetUser(
	ctx context.Context,
	req *pb.GetUserRequest,
) (*pb.GetUserResponse, error) {
	// メタデータの取得
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		return nil, status.Error(codes.Internal, "failed to get metadata")
	}
 
	// 認証チェック
	authTokens := md.Get("authorization")
	if len(authTokens) == 0 {
		return nil, status.Error(codes.Unauthenticated, "missing auth token")
	}
 
	// コンテキストのキャンセルチェック
	if ctx.Err() == context.Canceled {
		return nil, status.Error(codes.Canceled, "request canceled")
	}
	if ctx.Err() == context.DeadlineExceeded {
		return nil, status.Error(codes.DeadlineExceeded, "deadline exceeded")
	}
 
	s.mu.RLock()
	defer s.mu.RUnlock()
 
	user, exists := s.users[req.Id]
	if !exists {
		return nil, status.Errorf(
			codes.NotFound,
			"user %s not found", req.Id,
		)
	}
 
	// レスポンスメタデータの設定
	header := metadata.New(map[string]string{
		"x-request-id": fmt.Sprintf("req-%d", time.Now().UnixNano()),
	})
	grpc.SetHeader(ctx, header)
 
	return &pb.GetUserResponse{User: user}, nil
}
 
// Server Streaming RPC
func (s *userServer) ListUsers(
	req *pb.ListUsersRequest,
	stream pb.UserService_ListUsersServer,
) error {
	s.mu.RLock()
	defer s.mu.RUnlock()
 
	count := 0
	for _, user := range s.users {
		// コンテキストのキャンセルチェック
		if stream.Context().Err() != nil {
			return status.Error(codes.Canceled, "stream canceled")
		}
 
		if err := stream.Send(user); err != nil {
			return status.Errorf(codes.Internal, "send error: %v", err)
		}
 
		count++
		if req.PageSize > 0 && int32(count) >= req.PageSize {
			break
		}
	}
 
	return nil
}
 
// Client Streaming RPC
func (s *userServer) UploadUsers(
	stream pb.UserService_UploadUsersServer,
) error {
	var count int32
 
	for {
		user, err := stream.Recv()
		if err == io.EOF {
			// 全メッセージ受信完了
			return stream.SendAndClose(&pb.UploadUsersResponse{
				Count: count,
			})
		}
		if err != nil {
			return status.Errorf(codes.Internal, "recv error: %v", err)
		}
 
		s.mu.Lock()
		s.users[user.Id] = user
		s.mu.Unlock()
		count++
	}
}
 
// Bidirectional Streaming RPC
func (s *userServer) Chat(
	stream pb.UserService_ChatServer,
) error {
	for {
		msg, err := stream.Recv()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return status.Errorf(codes.Internal, "recv error: %v", err)
		}
 
		log.Printf("[%s] %s: %s", msg.RoomId, msg.From, msg.Text)
 
		// レスポンスを送信
		reply := &pb.ChatMessage{
			From:      "server",
			Text:      fmt.Sprintf("Echo: %s", msg.Text),
			Timestamp: time.Now().Unix(),
			RoomId:    msg.RoomId,
		}
 
		if err := stream.Send(reply); err != nil {
			return status.Errorf(codes.Internal, "send error: %v", err)
		}
	}
}
 
func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
 
	// サーバーオプション
	opts := []grpc.ServerOption{
		grpc.MaxRecvMsgSize(10 * 1024 * 1024), // 10MB
		grpc.MaxSendMsgSize(10 * 1024 * 1024), // 10MB
		grpc.KeepaliveParams(keepalive.ServerParameters{
			MaxConnectionIdle:     15 * time.Minute,
			MaxConnectionAge:      30 * time.Minute,
			MaxConnectionAgeGrace: 5 * time.Second,
			Time:                  5 * time.Minute,
			Timeout:               1 * time.Second,
		}),
		grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
			MinTime:             5 * time.Second,
			PermitWithoutStream: true,
		}),
	}
 
	s := grpc.NewServer(opts...)
	pb.RegisterUserServiceServer(s, newUserServer())
 
	log.Printf("gRPC server listening on %v", lis.Addr())
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

// === Rich Error Model（google.rpc.Status） ===
// Go での実装例
 
import (
	"google.golang.org/genproto/googleapis/rpc/errdetails"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)
 
func validateAndReturnError(req *pb.CreateUserRequest) error {
	// フィールドバリデーションエラー
	var violations []*errdetails.BadRequest_FieldViolation
 
	if req.Name == "" {
		violations = append(violations, &errdetails.BadRequest_FieldViolation{
			Field:       "name",
			Description: "Name is required and cannot be empty",
		})
	}
 
	if !isValidEmail(req.Email) {
		violations = append(violations, &errdetails.BadRequest_FieldViolation{
			Field:       "email",
			Description: "Email must be a valid email address",
		})
	}
 
	if req.Age < 0 || req.Age > 150 {
		violations = append(violations, &errdetails.BadRequest_FieldViolation{
			Field:       "age",
			Description: "Age must be between 0 and 150",
		})
	}
 
	if len(violations) > 0 {
		st := status.New(codes.InvalidArgument, "validation failed")
 
		br := &errdetails.BadRequest{
			FieldViolations: violations,
		}
 
		st, err := st.WithDetails(br)
		if err != nil {
			return status.Error(codes.Internal, "failed to attach error details")
		}
 
		return st.Err()
	}
 
	return nil
}
 
// リトライ情報付きエラー
func rateLimitError() error {
	st := status.New(codes.ResourceExhausted, "rate limit exceeded")
 
	retryInfo := &errdetails.RetryInfo{
		RetryDelay: durationpb.New(30 * time.Second),
	}
 
	st, _ = st.WithDetails(retryInfo)
	return st.Err()
}
 
// デバッグ情報付きエラー
func internalErrorWithDebug(err error) error {
	st := status.New(codes.Internal, "internal server error")
 
	debugInfo := &errdetails.DebugInfo{
		StackEntries: []string{
			"github.com/example/service/handler.go:42",
			"github.com/example/service/main.go:15",
		},
		Detail: err.Error(),
	}
 
	st, _ = st.WithDetails(debugInfo)
	return st.Err()
}

// === Go でのインターセプター ===
 
// Unary サーバーインターセプター（ログ）
func loggingUnaryInterceptor(
	ctx context.Context,
	req interface{},
	info *grpc.UnaryServerInfo,
	handler grpc.UnaryHandler,
) (interface{}, error) {
	start := time.Now()
 
	// メタデータの取得
	md, _ := metadata.FromIncomingContext(ctx)
	requestID := ""
	if ids := md.Get("x-request-id"); len(ids) > 0 {
		requestID = ids[0]
	}
 
	// ハンドラーの実行
	resp, err := handler(ctx, req)
 
	// ログ出力
	duration := time.Since(start)
	statusCode := codes.OK
	if err != nil {
		statusCode = status.Code(err)
	}
 
	log.Printf(
		"[%s] %s | %s | %v | %s",
		requestID,
		info.FullMethod,
		statusCode,
		duration,
		err,
	)
 
	return resp, err
}
 
// Unary サーバーインターセプター（認証）
func authUnaryInterceptor(
	ctx context.Context,
	req interface{},
	info *grpc.UnaryServerInfo,
	handler grpc.UnaryHandler,
) (interface{}, error) {
	// ヘルスチェック等は認証スキップ
	if info.FullMethod == "/grpc.health.v1.Health/Check" {
		return handler(ctx, req)
	}
 
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		return nil, status.Error(codes.Unauthenticated, "missing metadata")
	}
 
	tokens := md.Get("authorization")
	if len(tokens) == 0 {
		return nil, status.Error(codes.Unauthenticated, "missing token")
	}
 
	token := strings.TrimPrefix(tokens[0], "Bearer ")
 
	// トークン検証
	claims, err := validateToken(token)
	if err != nil {
		return nil, status.Errorf(codes.Unauthenticated, "invalid token: %v", err)
	}
 
	// コンテキストにユーザー情報を追加
	ctx = context.WithValue(ctx, "user_id", claims.UserID)
	ctx = context.WithValue(ctx, "user_roles", claims.Roles)
 
	return handler(ctx, req)
}
 
// Stream サーバーインターセプター（ログ）
func loggingStreamInterceptor(
	srv interface{},
	ss grpc.ServerStream,
	info *grpc.StreamServerInfo,
	handler grpc.StreamHandler,
) error {
	start := time.Now()
 
	err := handler(srv, ss)
 
	duration := time.Since(start)
	statusCode := codes.OK
	if err != nil {
		statusCode = status.Code(err)
	}
 
	log.Printf(
		"Stream %s | %s | %v",
		info.FullMethod,
		statusCode,
		duration,
	)
 
	return err
}
 
// リカバリーインターセプター（パニック回復）
func recoveryUnaryInterceptor(
	ctx context.Context,
	req interface{},
	info *grpc.UnaryServerInfo,
	handler grpc.UnaryHandler,
) (resp interface{}, err error) {
	defer func() {
		if r := recover(); r != nil {
			log.Printf("Panic recovered in %s: %v\n%s",
				info.FullMethod, r, debug.Stack())
			err = status.Errorf(codes.Internal, "internal error")
		}
	}()
	return handler(ctx, req)
}
 
// メトリクスインターセプター
func metricsUnaryInterceptor(
	ctx context.Context,
	req interface{},
	info *grpc.UnaryServerInfo,
	handler grpc.UnaryHandler,
) (interface{}, error) {
	start := time.Now()
 
	resp, err := handler(ctx, req)
 
	duration := time.Since(start)
	statusCode := status.Code(err)
 
	// Prometheus メトリクス記録
	grpcRequestsTotal.WithLabelValues(
		info.FullMethod,
		statusCode.String(),
	).Inc()
 
	grpcRequestDuration.WithLabelValues(
		info.FullMethod,
	).Observe(duration.Seconds())
 
	return resp, err
}
 
// サーバー起動時にインターセプターを設定
func main() {
	s := grpc.NewServer(
		grpc.ChainUnaryInterceptor(
			recoveryUnaryInterceptor,   // 1番目: パニック回復
			loggingUnaryInterceptor,    // 2番目: ログ
			metricsUnaryInterceptor,    // 3番目: メトリクス
			authUnaryInterceptor,       // 4番目: 認証
		),
		grpc.ChainStreamInterceptor(
			loggingStreamInterceptor,
		),
	)
	// ...
}

// === TypeScript でのインターセプター ===
 
// クライアント側インターセプター（リトライ）
import * as grpc from '@grpc/grpc-js';
 
function retryInterceptor(
  options: grpc.InterceptorOptions,
  nextCall: grpc.NextCall,
): grpc.InterceptingCall {
  const maxRetries = 3;
  const retryableStatuses = [
    grpc.status.UNAVAILABLE,
    grpc.status.DEADLINE_EXCEEDED,
    grpc.status.RESOURCE_EXHAUSTED,
  ];
 
  let retryCount = 0;
  let savedMetadata: grpc.Metadata;
  let savedMessage: any;
  let savedReceiveMessage: any;
 
  const requester = new grpc.RequesterBuilder()
    .withStart((metadata, listener, next) => {
      savedMetadata = metadata;
      const newListener = new grpc.ListenerBuilder()
        .withOnReceiveStatus((status, next) => {
          if (
            retryableStatuses.includes(status.code) &&
            retryCount < maxRetries
          ) {
            retryCount++;
            const delay = Math.pow(2, retryCount) * 100; // 指数バックオフ
            console.log(
              `Retrying (${retryCount}/${maxRetries}) after ${delay}ms`,
            );
            setTimeout(() => {
              // リトライ実行
              const newCall = nextCall(options);
              newCall.start(savedMetadata, listener);
              newCall.sendMessage(savedMessage);
              newCall.halfClose();
            }, delay);
          } else {
            next(status);
          }
        })
        .build();
      next(metadata, newListener);
    })
    .withSendMessage((message, next) => {
      savedMessage = message;
      next(message);
    })
    .build();
 
  return new grpc.InterceptingCall(nextCall(options), requester);
}
 
// クライアントにインターセプターを設定
const client = new proto.user.v1.UserService(
  'localhost:50051',
  grpc.credentials.createInsecure(),
  {
    interceptors: [retryInterceptor],
  },
);

// === gRPC-Web クライアント（ブラウザ） ===
// @connectrpc/connect-web を使用
 
import { createConnectTransport } from '@connectrpc/connect-web';
import { createClient } from '@connectrpc/connect';
import { UserService } from './gen/user/v1/user_service_connect';
 
// トランスポート作成
const transport = createConnectTransport({
  baseUrl: 'https://api.example.com',
  // gRPC-Web プロトコル使用
  // useBinaryFormat: true,
});
 
// クライアント作成
const client = createClient(UserService, transport);
 
// Unary RPC
async function getUser(id: string) {
  try {
    const response = await client.getUser({ id });
    console.log('User:', response.user);
    return response.user;
  } catch (error) {
    if (error instanceof ConnectError) {
      console.error(`Error [${error.code}]: ${error.message}`);
      // エラー詳細の取得
      for (const detail of error.details) {
        console.error('Detail:', detail);
      }
    }
    throw error;
  }
}
 
// Server Streaming
async function watchUsers() {
  try {
    for await (const event of client.watchUserUpdates({
      eventTypes: ['created', 'updated'],
    })) {
      console.log(`Event: ${event.eventType}`, event.user);
      // UIの更新
      updateUserList(event);
    }
  } catch (error) {
    console.error('Stream error:', error);
  }
}

// === デッドラインの実装（Go） ===
 
// クライアント側
func callWithDeadline(client pb.UserServiceClient) error {
	// 5秒のデッドラインを設定
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
 
	resp, err := client.GetUser(ctx, &pb.GetUserRequest{Id: "123"})
	if err != nil {
		st, ok := status.FromError(err)
		if ok && st.Code() == codes.DeadlineExceeded {
			log.Println("Request timed out!")
			return err
		}
		return err
	}
 
	log.Printf("User: %v", resp.User)
	return nil
}
 
// サーバー側（デッドラインチェック付き処理）
func (s *userServer) HeavyComputation(
	ctx context.Context,
	req *pb.HeavyRequest,
) (*pb.HeavyResponse, error) {
	results := make([]string, 0)
 
	for i := 0; i < 1000; i++ {
		// 定期的にデッドラインをチェック
		select {
		case <-ctx.Done():
			// デッドライン超過 or キャンセル
			return nil, status.Error(
				codes.DeadlineExceeded,
				"operation canceled due to deadline",
			)
		default:
			// 処理を続行
			result := processItem(i)
			results = append(results, result)
		}
	}
 
	return &pb.HeavyResponse{Results: results}, nil
}