Introduction

// user_service.proto
syntax = "proto3";
package user;
option go_package = "github.com/example/user";

import "google/protobuf/timestamp.proto";

service UserService {
  // User lifecycle operations
  rpc CreateUser(CreateUserRequest) returns (User);
  rpc GetUser(GetUserRequest) returns (User);
  rpc UpdateUser(UpdateUserRequest) returns (User);
  rpc DeleteUser(DeleteUserRequest) returns (DeleteUserResponse);
  
  // Domain-specific operations
  rpc VerifyUserEmail(VerifyUserEmailRequest) returns (VerifyUserEmailResponse);
  rpc ResetPassword(ResetPasswordRequest) returns (ResetPasswordResponse);
  
  // Batch operations for efficiency
  rpc GetUsers(GetUsersRequest) returns (GetUsersResponse);
}

message User {
  string id = 1;
  string email = 2;
  string display_name = 3;
  bool email_verified = 4;
  google.protobuf.Timestamp created_at = 5;
  google.protobuf.Timestamp updated_at = 6;
}

// Other message definitions...

// v1/payment_service.proto
syntax = "proto3";
package payment.v1;
option go_package = "github.com/example/payment/v1";

service PaymentService {
  rpc ProcessPayment(ProcessPaymentRequest) returns (ProcessPaymentResponse);
  // Other methods...
}

// v2/payment_service.proto
syntax = "proto3";
package payment.v2;
option go_package = "github.com/example/payment/v2";

service PaymentService {
  rpc ProcessPayment(ProcessPaymentRequest) returns (ProcessPaymentResponse);
  // Enhanced methods with additional features
  rpc ProcessPaymentWithAnalytics(ProcessPaymentWithAnalyticsRequest) 
      returns (ProcessPaymentWithAnalyticsResponse);
}

package main

import (
	"context"
	"log"
	"net"

	v1 "github.com/example/payment/v1"
	v2 "github.com/example/payment/v2"
	"google.golang.org/grpc"
)

type paymentServiceV1 struct {
	v1.UnimplementedPaymentServiceServer
}

type paymentServiceV2 struct {
	v2.UnimplementedPaymentServiceServer
}

// V1 implementation
func (s *paymentServiceV1) ProcessPayment(ctx context.Context, req *v1.ProcessPaymentRequest) (*v1.ProcessPaymentResponse, error) {
	// V1 implementation
	return &v1.ProcessPaymentResponse{
		Success: true,
		TransactionId: "v1-transaction",
	}, nil
}

// V2 implementation
func (s *paymentServiceV2) ProcessPayment(ctx context.Context, req *v2.ProcessPaymentRequest) (*v2.ProcessPaymentResponse, error) {
	// V2 implementation with enhanced features
	return &v2.ProcessPaymentResponse{
		Success: true,
		TransactionId: "v2-transaction",
		Fee: &v2.Fee{
			Amount: req.Amount * 0.01,
			Currency: req.Currency,
		},
	}, nil
}

func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	
	server := grpc.NewServer()
	
	// Register both service versions
	v1.RegisterPaymentServiceServer(server, &paymentServiceV1{})
	v2.RegisterPaymentServiceServer(server, &paymentServiceV2{})
	
	log.Println("Starting gRPC server on :50051")
	if err := server.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

syntax = "proto3";
package catalog;
option go_package = "github.com/example/catalog";

import "google/protobuf/any.proto";
import "google/protobuf/field_mask.proto";

// Using oneofs for mutually exclusive fields
message Product {
  string id = 1;
  string name = 2;
  string description = 3;
  
  oneof pricing {
    FixedPrice fixed_price = 4;
    DynamicPrice dynamic_price = 5;
    SubscriptionPrice subscription_price = 6;
  }
  
  // Using maps for efficient key-value data
  map<string, string> attributes = 7;
  
  // Using Any for extensibility
  repeated google.protobuf.Any extensions = 8;
}

message FixedPrice {
  double amount = 1;
  string currency = 2;
}

message DynamicPrice {
  double base_amount = 1;
  string currency = 2;
  repeated PricingRule rules = 3;
}

message SubscriptionPrice {
  double monthly_amount = 1;
  double annual_amount = 2;
  string currency = 3;
}

message PricingRule {
  string rule_type = 1;
  double adjustment = 2;
}

// Using field masks for partial updates
message UpdateProductRequest {
  string product_id = 1;
  Product product = 2;
  google.protobuf.FieldMask update_mask = 3;
}

package main

import (
	"context"
	
	"github.com/example/catalog"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/proto"
)

type catalogService struct {
	catalog.UnimplementedCatalogServiceServer
	products map[string]*catalog.Product
}

func (s *catalogService) UpdateProduct(ctx context.Context, req *catalog.UpdateProductRequest) (*catalog.Product, error) {
	productID := req.ProductId
	existingProduct, exists := s.products[productID]
	if !exists {
		return nil, status.Errorf(codes.NotFound, "product not found: %s", productID)
	}
	
	// Create a copy of the existing product
	updatedProduct := proto.Clone(existingProduct).(*catalog.Product)
	
	// Apply updates based on field mask
	if req.UpdateMask != nil && len(req.UpdateMask.Paths) > 0 {
		// Apply only the fields specified in the mask
		for _, path := range req.UpdateMask.Paths {
			switch path {
			case "name":
				updatedProduct.Name = req.Product.Name
			case "description":
				updatedProduct.Description = req.Product.Description
			case "fixed_price":
				if req.Product.GetFixedPrice() != nil {
					updatedProduct.Pricing = &catalog.Product_FixedPrice{
						FixedPrice: proto.Clone(req.Product.GetFixedPrice()).(*catalog.FixedPrice),
					}
				}
			// Handle other fields...
			default:
				return nil, status.Errorf(codes.InvalidArgument, "unsupported field path: %s", path)
			}
		}
	} else {
		// No field mask provided, replace the entire product except ID
		req.Product.Id = productID
		updatedProduct = req.Product
	}
	
	// Update the product in the store
	s.products[productID] = updatedProduct
	return updatedProduct, nil
}