Migrating NestJS Microservices with TypeScript to Go: A Week of Discoveries

Migrating NestJS Microservices with TypeScript to Go: A Week of Discoveries

In the last week, I have immersed myself in the world of Go with the aim of migrating our microservices developed in NestJS with TypeScript. This journey has been an intense exercise in unlearning certain paradigms and adopting others, understanding the fundamental differences between these two development ecosystems.

Our Architecture in NestJS

In our stack with NestJS, we manage microservices connected to PostgreSQL and Redis databases. We implement various communication strategies between microservices:

1. Communication by Events: We use Pub/Sub for subscriptions and topics that allow asynchronous communication between microservices.
2. Backend for Frontend (BFF): We implement REST APIs protected with JWT, which serve as intermediaries between the frontend and the database.

Validations and Migrations

DTO validation and data migration are crucial in our system. TypeScript has allowed us to define strict types and structures with Knex and TypeORM to handle migrations. Although effective, this approach requires a deep understanding of the language and how to manipulate data streams across different microservices.

Challenges with NestJS

We detected event loop issues that affected performance, which we addressed using the Clinic.js library. We identified bottlenecks and optimized the use of design patterns along with async and await. However, managing concurrency in Node.js can be complex and expensive in terms of resources.

Getting into Go

When exploring Go, we encounter a paradigm transition and a series of significant differences:

1. Compilation and Static Typing: Unlike TypeScript, Go is a compiled language with strong static typing, which forces us to detect errors at compile time.
2. Control Flow and Error Handling: Go simplifies error handling through its explicit focus on returning errors, rather than exceptions.
3. Data Structure and Memory: Memory allocation and data structure management in Go requires a deeper understanding of the hardware, which is different from the more abstract approach of JavaScript.

OOP and Interfaces

In Go, although object orientation is supported, it manifests itself differently. The absence of traditional inheritance and the use of interfaces provides a distinct flexibility that must be thoroughly understood to take full advantage.

Comparative Examples

Data Validation

• NestJS: We use Decorators in DTOs for validation.
  

  import { IsString, IsInt } from 'class-validator';
  
  class CreateUserDto {
      @IsString()
      name: string;
  
      @IsInt()
      age: number;
  }
  

• Go: We use libraries like go-playground/validator for validation.
  

  import (
      "gopkg.in/go-playground/validator.v9"
  )
  
  type User struct {
      Name string `validate:"required"`
      Age  int    `validate:"gte=0"`
  }
  
  validate := validator.New()
  user := &User{Name: "Alice", Age: 25}
  err := validate.Struct(user)
  

Asynchronous Communication

• NestJS: Using async/await to handle promises.
  

  async function fetchData(): Promise<void> {
      const data = await apiCall();
      console.log(data);
  }
  

• Go: Use of goroutines and channels for concurrency.
  

  func fetchData() {
      dataChan := make(chan string)
      go func() {
          dataChan <- apiCall()
      }()
      data := <-dataChan
      fmt.Println(data)
  }
  

Tools and Settings

In Go, we have adopted tools like Gin for REST APIs and Gorm as ORM. Setting up our environment in VSCode with make to automate tasks has been crucial to maintaining productivity and adapting to this new workflow.

Final Thoughts

Migrating from NestJS with TypeScript to Go has been challenging but also rewarding. While NestJS offers a rich experience in rapid API development with a focus on reuse and abstraction, Go has given us more granular control over concurrency and performance, essential for highly scalable applications.

We continue to experiment and adjust our workflows, and despite the challenges, we are excited about the possibilities that Go offers for the future of our microservices.

---

I hope this blog serves as a guide and inspiration to those considering a similar transition. What experiences have you had with technology migration? What challenges and solutions have you found along the way?

Share your stories and let's continue learning together!

The above is the detailed content of Migrating NestJS Microservices with TypeScript to Go: A Week of Discoveries. For more information, please follow other related articles on the PHP Chinese website!