const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
 transport: Transport.GRPC,
 options: {
   package: 'hero',
   protoPath: join(__dirname, 'hero/hero.proto'),
 },
});

// hero/hero.proto
syntax = "proto3";

package hero;

service HeroesService {
  rpc FindOne (HeroById) returns (Hero) {}
}

message HeroById {
  int32 id = 1;
}

message Hero {
  int32 id = 1;
  string name = 2;
}

@Controller()
export class HeroesController {
 @GrpcMethod('HeroesService', 'FindOne')
 findOne(data: HeroById, metadata: Metadata, call: ServerUnaryCall<any, any>): Hero {
   const items = [
     { id: 1, name: 'John' },
     { id: 2, name: 'Doe' },
   ];
   return items.find(({ id }) => id === data.id);
 }
}

@Controller()
export class HeroesController {
 @GrpcMethod('HeroesService')
 findOne(data: HeroById, metadata: Metadata, call: ServerUnaryCall<any, any>): Hero {
   const items = [
     { id: 1, name: 'John' },
     { id: 2, name: 'Doe' },
   ];
   return items.find(({ id }) => id === data.id);
 }
}

@Controller()
export class HeroesService {
 @GrpcMethod()
 findOne(data: HeroById, metadata: Metadata, call: ServerUnaryCall<any, any>): Hero {
   const items = [
     { id: 1, name: 'John' },
     { id: 2, name: 'Doe' },
   ];
   return items.find(({ id }) => id === data.id);
 }
}

imports: [
  ClientsModule.register([
    {
      name: 'HERO_PACKAGE',
      transport: Transport.GRPC,
      options: {
        package: 'hero',
        protoPath: join(__dirname, 'hero/hero.proto'),
      },
    },
  ]),
];

@Injectable()
export class AppService implements OnModuleInit {
  private heroesService: HeroesService;

  constructor(@Inject('HERO_PACKAGE') private client: ClientGrpc) {}

  onModuleInit() {
    this.heroesService = this.client.getService<HeroesService>('HeroesService');
  }

  getHero(): Observable<string> {
    return this.heroesService.findOne({ id: 1 });
  }
}

@Injectable()
export class AppService implements OnModuleInit {
  @Client({
    transport: Transport.GRPC,
    options: {
      package: 'hero',
      protoPath: join(__dirname, 'hero/hero.proto'),
    },
  })
  client: ClientGrpc;

  private heroesService: HeroesService;

  onModuleInit() {
    this.heroesService = this.client.getService<HeroesService>('HeroesService');
  }

  getHero(): Observable<string> {
    return this.heroesService.findOne({ id: 1 });
  }
}

interface HeroesService {
  findOne(data: { id: number }): Observable<any>;
}

@Get()
call(): Observable<any> {
 return this.heroesService.findOne({ id: 1 });
}

call(): Observable<any> {
  const metadata = new Metadata();
  metadata.add('Set-Cookie', 'yummy_cookie=choco');

  return this.heroesService.findOne({ id: 1 }, metadata);
}

import { ReflectionService } from '@grpc/reflection';

const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
 options: {
   onLoadPackageDefinition: (pkg, server) => {
     new ReflectionService(pkg).addToServer(server);
   },
 },
});

// hello/hello.proto
syntax = "proto3";

package hello;

service HelloService {
  rpc BidiHello(stream HelloRequest) returns (stream HelloResponse);
  rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string greeting = 1;
}

message HelloResponse {
  string reply = 1;
}

interface HelloService {
  bidiHello(upstream: Observable<HelloRequest>): Observable<HelloResponse>;
  lotsOfGreetings(
    upstream: Observable<HelloRequest>
  ): Observable<HelloResponse>;
}

interface HelloRequest {
  greeting: string;
}

interface HelloResponse {
  reply: string;
}

@GrpcStreamMethod()
bidiHello(messages: Observable<any>, metadata: Metadata, call: ServerDuplexStream<any, any>): Observable<any> {
  const subject = new Subject();

  const onNext = message => {
    console.log(message);
    subject.next({
      reply: 'Hello, world!'
    });
  };
  const onComplete = () => subject.complete();
  messages.subscribe({
    next: onNext,
    complete: onComplete,
  });


  return subject.asObservable();
}

const helloService = this.client.getService<HelloService>('HelloService');
const helloRequest$ = new ReplaySubject<HelloRequest>();

helloRequest$.next({ greeting: 'Hello (1)!' });
helloRequest$.next({ greeting: 'Hello (2)!' });
helloRequest$.complete();

return helloService.bidiHello(helloRequest$);

@GrpcStreamCall()
bidiHello(requestStream: any) {
  requestStream.on('data', message => {
    console.log(message);
    requestStream.write({
      reply: 'Hello, world!'
    });
  });
}

@GrpcStreamCall()
lotsOfGreetings(requestStream: any, callback: (err: unknown, value: HelloResponse) => void) {
  requestStream.on('data', message => {
    console.log(message);
  });
  requestStream.on('end', () => callback(null, { reply: 'Hello, world!' }));
}

import { HealthImplementation, protoPath as healthCheckProtoPath } from 'grpc-health-check';

const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
 options: {
   protoPath: [
     healthCheckProtoPath,
     protoPath: join(__dirname, 'hero/hero.proto'),
   ],
   onLoadPackageDefinition: (pkg, server) => {
     const healthImpl = new HealthImplementation({
       '': 'UNKNOWN',
     });

     healthImpl.addToServer(server);
     healthImpl.setStatus('', 'SERVING');
   },
 },
});

@Controller()
export class HeroesService {
 @GrpcMethod()
 findOne(data: HeroById, metadata: Metadata, call: ServerUnaryCall<any, any>): Hero {
   const serverMetadata = new Metadata();
   const items = [
     { id: 1, name: 'John' },
     { id: 2, name: 'Doe' },
   ];

   serverMetadata.add('Set-Cookie', 'yummy_cookie=choco');
   call.sendMetadata(serverMetadata);

   return items.find(({ id }) => id === data.id);
 }
}

requestStream.on('metadata', (metadata: Metadata) => {
  const meta = metadata.get('X-Meta');
});