REST, GraphQL e gRPC

import * as grpc from "@grpc/grpc-js";
import * as protoLoader from "@grpc/proto-loader";

const definicao = protoLoader.loadSync("pedidos.proto");
const pacote = grpc.loadPackageDefinition(definicao) as any;

const pedidos = new Map([
  [
    "981",
    {
      id: "981",
      status: "enviado",
      itens: [{ produto: "teclado", quantidade: 2 }],
    },
  ],
]);

const servidor = new grpc.Server();

servidor.addService(pacote.loja.v1.Pedidos.service, {
  BuscarPedido(chamada: any, responder: any) {
    const pedido = pedidos.get(chamada.request.id);
    if (!pedido) {
      return responder({
        code: grpc.status.NOT_FOUND,
        message: "pedido não encontrado",
      });
    }
    responder(null, pedido);
  },
});

servidor.bindAsync(
  "0.0.0.0:50051",
  grpc.ServerCredentials.createInsecure(),
  () => console.log("gRPC na porta 50051"),
);

from concurrent import futures

import grpc

import pedidos_pb2
import pedidos_pb2_grpc

PEDIDOS = {
    "981": pedidos_pb2.Pedido(
        id="981",
        status="enviado",
        itens=[pedidos_pb2.Item(produto="teclado", quantidade=2)],
    )
}


class Pedidos(pedidos_pb2_grpc.PedidosServicer):
    def BuscarPedido(self, request, context):
        pedido = PEDIDOS.get(request.id)
        if pedido is None:
            context.abort(grpc.StatusCode.NOT_FOUND, "pedido não encontrado")
        return pedido


servidor = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
pedidos_pb2_grpc.add_PedidosServicer_to_server(Pedidos(), servidor)
servidor.add_insecure_port("[::]:50051")
servidor.start()
servidor.wait_for_termination()

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	lojav1 "exemplo.com/loja/v1"
)

type servidor struct {
	lojav1.UnimplementedPedidosServer
}

var pedidos = map[string]*lojav1.Pedido{
	"981": {
		Id:     "981",
		Status: "enviado",
		Itens:  []*lojav1.Item{{Produto: "teclado", Quantidade: 2}},
	},
}

func (s *servidor) BuscarPedido(
	ctx context.Context,
	req *lojav1.BuscarPedidoRequest,
) (*lojav1.Pedido, error) {
	pedido, existe := pedidos[req.GetId()]
	if !existe {
		return nil, status.Error(codes.NotFound, "pedido não encontrado")
	}
	return pedido, nil
}

func main() {
	porta, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatal(err)
	}

	s := grpc.NewServer()
	lojav1.RegisterPedidosServer(s, &servidor{})
	log.Fatal(s.Serve(porta))
}

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import java.util.Map;

public class PedidosService extends PedidosGrpc.PedidosImplBase {

    private static final Map<String, Pedido> PEDIDOS = Map.of(
        "981",
        Pedido.newBuilder()
            .setId("981")
            .setStatus("enviado")
            .addItens(Item.newBuilder().setProduto("teclado").setQuantidade(2))
            .build());

    @Override
    public void buscarPedido(
            BuscarPedidoRequest request,
            StreamObserver<Pedido> resposta) {
        Pedido pedido = PEDIDOS.get(request.getId());
        if (pedido == null) {
            resposta.onError(Status.NOT_FOUND
                .withDescription("pedido não encontrado")
                .asRuntimeException());
            return;
        }
        resposta.onNext(pedido);
        resposta.onCompleted();
    }

    public static void main(String[] args) throws Exception {
        Server servidor = ServerBuilder.forPort(50051)
            .addService(new PedidosService())
            .build()
            .start();
        servidor.awaitTermination();
    }
}

using Grpc.Core;
using Loja.V1;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddGrpc();

var app = builder.Build();
app.MapGrpcService<PedidosService>();
app.Run();

public class PedidosService : Pedidos.PedidosBase
{
    private static readonly Dictionary<string, Pedido> Dados = new()
    {
        ["981"] = new Pedido
        {
            Id = "981",
            Status = "enviado",
            Itens = { new Item { Produto = "teclado", Quantidade = 2 } },
        },
    };

    public override Task<Pedido> BuscarPedido(
        BuscarPedidoRequest request,
        ServerCallContext context)
    {
        if (!Dados.TryGetValue(request.Id, out var pedido))
        {
            throw new RpcException(
                new Status(StatusCode.NotFound, "pedido não encontrado"));
        }
        return Task.FromResult(pedido);
    }
}