gRPC para TypeScript: bibliotecas, configuración y ejemplos de código

gRPC para TypeScript: bibliotecas y ejemplos

gRPC es un framework moderno de alto rendimiento para llamadas a procedimientos remotos (RPC), desarrollado por Google. Utiliza Protocol Buffers (protobuf) como lenguaje de definición de interfaces y formato de serialización de datos. En TypeScript, gRPC se implementa a través de los paquetes @grpc/grpc-js (para la lógica del servidor y del cliente) y protobufjs (para trabajar con archivos .proto). En este artículo, analizaremos las bibliotecas clave, la configuración del entorno y escribiremos un ejemplo funcional en TypeScript.

Bibliotecas clave para gRPC en TypeScript

• @grpc/grpc-js — una implementación pura de JavaScript de gRPC (sin complementos C++). Soporta todas las funciones principales: llamadas unarias, streaming del servidor y del cliente, y streaming bidireccional.
• protobufjs — biblioteca para cargar, analizar y generar clases a partir de archivos .proto. Permite crear mensajes y servicios dinámicamente.
• @grpc/proto-loader — paquete auxiliar que simplifica la carga de archivos proto y genera automáticamente tipos TypeScript basados en las definiciones.
• ts-protoc-gen — generador de código para el compilador protoc. Permite generar clases e interfaces fuertemente tipadas a partir de archivos .proto.

Para la mayoría de los proyectos, la combinación de @grpc/grpc-js + @grpc/proto-loader es suficiente. Si se requiere la máxima seguridad de tipos, se utiliza ts-protoc-gen o protobufjs con generación de tipos estáticos.

Instalación de dependencias

Cree un nuevo proyecto e instale los paquetes necesarios:

mkdir grpc-typescript-examplecd grpc-typescript-examplenpm init -ynpm install @grpc/grpc-js @grpc/proto-loadernpm install -D typescript @types/nodenpx tsc --init

Creación del archivo proto

Definamos un servicio simple para trabajar con usuarios. Cree el archivo user.proto:

syntax = "proto3";

package user;

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

message GetUserRequest {  int32 id = 1;}

message ListUsersRequest {  int32 page = 1;  int32 limit = 2;}

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

Implementación del servidor gRPC en TypeScript

Creemos el archivo server.ts:

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

const PROTO_PATH = path.join(__dirname, 'user.proto');

const packageDefinition = protoLoader.loadSync(PROTO_PATH, {  keepCase: true,  longs: String,  enums: String,  defaults: true,  oneofs: true,});

const userProto = grpc.loadPackageDefinition(packageDefinition) as any;

// Simulación de base de datosconst users = [  { id: 1, name: 'Alice', email: 'alice@example.com' },  { id: 2, name: 'Bob', email: 'bob@example.com' },];

function getUser(  call: grpc.ServerUnaryCall<{ id: number }, any>,  callback: grpc.sendUnaryData<any>) {  const user = users.find(u => u.id === call.request.id);  if (!user) {    return callback({      code: grpc.status.NOT_FOUND,      message: 'User not found',    });  }  callback(null, user);}

function listUsers(call: grpc.ServerWritableStream<{ page: number; limit: number }, any>) {  const page = call.request.page || 1;  const limit = call.request.limit || 10;  const start = (page - 1) * limit;  const end = start + limit;  const paginatedUsers = users.slice(start, end);  paginatedUsers.forEach(user => call.write(user));  call.end();}

function main() {  const server = new grpc.Server();