ts-proto: NESTJS - `Error: 12 UNIMPLEMENTED: The server does not implement this method`

I am using the new nestjs proto and i implemented the interfaces on the server and client however i am getting Error: 12 UNIMPLEMENTED: The server does not implement this method.

The following code is for client, server, and my proto file in TS.

import { Inject, Injectable, Logger, OnModuleInit } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { Observable } from 'rxjs';
import {
  US_CITIES_PACKAGE_NAME,
  US_CITIES_SERVICE_PROTO_SERVICE_NAME,
  USCitiesResponse,
  USCitiesServiceProtoClient,
  USCityResponse,
} from '../interfaces/us-cities';

@Injectable()
export class USCitiesService implements OnModuleInit {
  private readonly logger = new Logger(USCitiesService.name);
  private uSCitiesServiceProtoClient: USCitiesServiceProtoClient;

  constructor(@Inject(US_CITIES_PACKAGE_NAME) private client: ClientGrpc) {}

  onModuleInit() {
    this.uSCitiesServiceProtoClient = this.client.getService<
      USCitiesServiceProtoClient
    >(US_CITIES_SERVICE_PROTO_SERVICE_NAME);
  }

  getUSCity(id: number): Observable<USCityResponse> {
    return this.uSCitiesServiceProtoClient.getUSCity({ id });
  }

  getUSCities(): Observable<USCitiesResponse> {
    return this.uSCitiesServiceProtoClient.getUSCities({});
  }
}

import { Controller, Logger } from '@nestjs/common';
import { USCitiesService } from './us-cities.service';
import {
  USCitiesResponse, USCitiesServiceProtoController, USCitiesServiceProtoControllerMethods,
  USCityRequest,
  USCityResponse,
} from '../interfaces/us-cities';

@Controller()
@USCitiesServiceProtoControllerMethods()
export class USCitiesController implements USCitiesServiceProtoController {
  private readonly logger = new Logger(USCitiesController.name);
  constructor(private uSCitiesService: USCitiesService) {}

  async getUSCity(data: USCityRequest): Promise<USCityResponse> {
    this.logger.debug('accessing GetUSCity');
    const result = await this.uSCitiesService.getUSCity(data.id);
    return { uSCity: result };
  }

  async getUSCities(): Promise<USCitiesResponse> {
    this.logger.debug('accessing GetUSCities');
    const results = await this.uSCitiesService.getUSCities();
    return {
      uSCities: results,
    };
  }
}

/* eslint-disable */
import { Observable } from 'rxjs';
import { Empty } from './google/protobuf/empty';
import { GrpcMethod, GrpcStreamMethod } from '@nestjs/microservices';

export interface USCityRequest {
  id: number;
}

export interface USCitiesResponse {
  uSCities: USCity[];
}

export interface USCityResponse {
  uSCity: USCity | undefined;
}

export interface USCity {
  id: number;
  idState: number;
  city: string;
  county: string;
  latitude: number;
  longitude: number;
}

export interface USCitiesServiceProtoController {
  getUSCity(
    request: USCityRequest,
  ): Promise<USCityResponse> | Observable<USCityResponse> | USCityResponse;

  getUSCities(
    request: Empty,
  ):
    | Promise<USCitiesResponse>
    | Observable<USCitiesResponse>
    | USCitiesResponse;
}

export interface USCitiesServiceProtoClient {
  getUSCity(request: USCityRequest): Observable<USCityResponse>;

  getUSCities(request: Empty): Observable<USCitiesResponse>;
}

export function USCitiesServiceProtoControllerMethods() {
  return function(constructor: Function) {
    const grpcMethods: string[] = ['getUSCity', 'getUSCities'];
    for (const method of grpcMethods) {
      const descriptor: any = Reflect.getOwnPropertyDescriptor(
        constructor.prototype,
        method,
      );
      GrpcMethod('USCitiesServiceProto', method)(
        constructor.prototype[method],
        method,
        descriptor,
      );
    }
    const grpcStreamMethods: string[] = [];
    for (const method of grpcStreamMethods) {
      const descriptor: any = Reflect.getOwnPropertyDescriptor(
        constructor.prototype,
        method,
      );
      GrpcStreamMethod('USCitiesServiceProto', method)(
        constructor.prototype[method],
        method,
        descriptor,
      );
    }
  };
}

export const US_CITIES_PACKAGE_NAME = 'us.cities';
export const US_CITIES_SERVICE_PROTO_SERVICE_NAME = 'USCitiesServiceProto';