Forem: Sylvester Asare Sarpong

gRPC, Dependency Injection with Uber Fx, and Hexagonal Architecture in Go

Sylvester Asare Sarpong — Thu, 27 Nov 2025 20:02:56 +0000

Introduction

Modern microservices require clean separation of concerns, testable code, and efficient inter-service communication. In this comprehensive tutorial, we'll explore three powerful patterns that work together to create maintainable, scalable Go applications:

gRPC for fast, type-safe service-to-service communication
Dependency Injection using Uber Fx for clean architecture
Hexagonal Architecture for flexible, testable business logic

By the end of this article, you'll understand how to combine these patterns to build professional-grade microservices in Go.

Understanding gRPC

gRPC is a high-performance, open-source framework developed by Google. The name stands for Google Remote Procedure Call. Let's break down what that means.

What is Remote Procedure Call (RPC)?

A Remote Procedure Call (RPC) is a protocol that allows a program on one computer to execute a function on another computer as if it were a local call. This abstraction makes distributed systems feel more like monolithic applications.

Consider this simple function in pseudo-code:

func calculateAreaOfSquare(s float64) float64 {
    area := s * s
    return area
}

Now imagine our programming environment doesn't have a multiplication function, and we need to calculate the area using an external service.

Traditional HTTP API Approach

Without gRPC, you might call an external service like this:

func calculateAreaOfSquare(s float64) float64 {
    // Call an external math API over HTTP
    area := xhr.fetch("api.math.edu/multiply?s=" + s + "&t=" + s)
    return area
}

The problem? Standard HTTP APIs typically operate over HTTP/1.1, where you send a request and wait for a response. This involves:

Text-based serialization (JSON/XML)
Request/response overhead
Slower performance
Manual client implementation

The gRPC Advantage

gRPC makes remote calls feel like local function calls:

func calculateAreaOfSquare(s float64) float64 {
    // gRPC call - looks and feels local
    area := multiply(s, s)
    return area
}

Even though the multiply function might be implemented on another server or even written in a different language like Java, Python, or Rust you can call it as if it were part of your Go application.

Why Choose gRPC?

Key Benefits:

Fast: Uses HTTP/2 with binary serialization (Protocol Buffers)
Type-safe: Strongly-typed contracts prevent runtime errors
Language-agnostic: Write services in any language gRPC supports
Bidirectional streaming: Supports client, server, and bidirectional streaming
Built-in code generation: Automatically generates client and server code

Real-world example: You could build a web server in Go that leverages specialized machine learning functions from a Python service, or authentication services from a Java application all with seamless, performant communication.

gRPC Contracts: The Foundation

gRPC operates on the principle of contracts. When services communicate especially across different programming languages there must be a clear agreement on:

Available functions: What can be called?
Input parameters: What data does each function accept and what are their types?
Return values: What does each function return?

This contract is defined using Protocol Buffers (protobufs), a language-neutral serialization format.

What gRPC Provides

gRPC doesn't care about how a function is implemented. Instead, it provides:

Accessors for arguments: Methods to read the data you send
Accessors for responses: Methods to read the data you receive

That's all you need: pass the required arguments and receive results, exactly like calling a local function.

gRPC in Action: Protobuf Contracts

Let's look at a practical example a simple greeting service defined in Protocol Buffers:

// The greeting service definition
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name
message HelloRequest {
  string name = 1;
}

// The response message containing the greeting
message HelloReply {
  string message = 1;
}

Breaking it down:

We define a service called Greeter
It has an RPC method SayHello
SayHello takes a HelloRequest message with a name field (type: string)
It returns a HelloReply message with a message field (type: string)

The contract explicitly specifies expected inputs and outputs, allowing gRPC to automatically generate type-safe client and server code.

Creating Our Calculator Service

Let's define a more practical example a calculator service:

// The calculator service definition
service Calculator {
  // Adds two numbers
  rpc Add (OperationRequest) returns (OperationResponse) {}
}

message OperationRequest {
  float a = 1;
  float b = 2;
}

message OperationResponse {
  float result = 1;
}

Understanding the structure:

Calculator is the service (a logical grouping of related methods)
Add is an RPC method (we're using unary RPC one request, one response)
OperationRequest contains two fields: a and b
OperationResponse contains a single field: result

Note: There are four types of gRPC methods: unary, client streaming, server streaming, and bidirectional streaming. This tutorial focuses on unary RPCs (single request → single response) for simplicity.

For now, we've defined just one operation. Once comfortable with the pattern, you can extend the service with subtraction, multiplication, division, and more complex operations.

Setting Up Your gRPC Development Environment

Before writing code, let's set up all necessary tools and dependencies.

1. Install Go

Verify Go is installed:

go version

If not installed, download from: https://golang.org/dl/

2. Initialize a Go Module

Create your project directory and initialize a module:

mkdir grpc-hexagonal-demo
cd grpc-hexagonal-demo
go mod init github.com/yourusername/grpc-hexagonal-demo

This creates a go.mod file to manage your project's dependencies.

3. Install gRPC and Protobuf Support

Install the gRPC package for Go:

go get google.golang.org/grpc
go get google.golang.org/protobuf

4. Install Protocol Buffers Compiler (protoc)

macOS (using Homebrew):

brew install protobuf

Linux (Debian/Ubuntu):

sudo apt install -y protobuf-compiler

Verify installation:

protoc --version

You should see output like: libprotoc 3.x.x or newer.

5. Install Go Plugins for Protobuf

These plugins generate Go code from .proto files:

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

Add Go bin to your PATH:

export PATH="$PATH:$(go env GOPATH)/bin"

Add this line to your shell profile (~/.bashrc, ~/.zshrc, etc.) to make it permanent.

6. Verify Your Setup

Test that code generation works:

protoc --go_out=. --go-grpc_out=. pkg/protos/*.proto

If no errors appear, your environment is ready!

Project Structure

We'll organize our project following Go best practices:

grpc-hexagonal-demo/
├── cmd/
│   └── server/
│       └── main.go           # Server entry point
├── internal/
│   ├── app/                  # Fx modules and wiring
│   ├── domain/               # Core business logic and ports
│   ├── services/             # Domain service implementations
│   └── adapters/
│       ├── grpc/             # gRPC handlers (driving adapter)
│       └── db/               # Repository implementations (driven adapter)
├── pkg/
│   └── protos/               # Protobuf definitions
│       └── calculator.proto
├── go.mod
├── go.sum
└── Taskfile.yml              # Task automation

Directory purposes:

cmd/server/main.go: Application entry point
internal/app: Dependency injection wiring with Uber Fx
internal/domain: Pure business logic and interface definitions (ports)
internal/services: Business logic implementations
internal/adapters/grpc: gRPC server handlers
internal/adapters/db: Database repositories (when needed)
pkg/protos: Protobuf contracts (.proto files)
Taskfile.yml: Task runner for automating repetitive commands

Automating Code Generation with Taskfile

Instead of manually running protoc every time you modify your .proto files, use Taskfile (a modern alternative to Makefiles).

Install Taskfile:

# macOS
brew install go-task/tap/go-task

# Linux
sh -c "$(curl --location https://taskfile.dev/install.sh)" -- -d -b ~/.local/bin

# Or using Go
go install github.com/go-task/task/v3/cmd/task@latest

Create Taskfile.yml:

version: "3"

tasks:
  proto-gen:
    desc: Generate Go code from protobuf files
    cmds:
      - protoc --go_out=. --go_opt=paths=source_relative \
               --go-grpc_out=. --go-grpc_opt=paths=source_relative \
               pkg/protos/*.proto

  run:
    desc: Run the gRPC server
    cmds:
      - go run cmd/server/main.go

  build:
    desc: Build the server binary
    cmds:
      - go build -o bin/server cmd/server/main.go

Usage:

# Generate protobuf code
task proto-gen

# Run the server
task run

# Build the binary
task build

Taskfile simplifies your workflow and makes commands discoverable for team members.

Defining the Protobuf Contract

Create your calculator service contract:

File: pkg/protos/calculator.proto

syntax = "proto3";

package calculator;

option go_package = "github.com/yourusername/grpc-hexagonal-demo/pkg/protos";

// The calculator service definition
service Calculator {
  // Adds two numbers
  rpc Add (OperationRequest) returns (OperationResponse) {}

  // Multiplies two numbers
  rpc Multiply (OperationRequest) returns (OperationResponse) {}

  // Divides two numbers
  rpc Divide (OperationRequest) returns (OperationResponse) {}
}

// Request message containing two operands
message OperationRequest {
  float a = 1;
  float b = 2;
}

// Response message containing the result
message OperationResponse {
  float result = 1;
}

Generate the Go code:

task proto-gen

This creates two files in pkg/protos/:

calculator.pb.go: Message definitions
calculator_grpc.pb.go: Service interface and client code

Creating a Basic gRPC Server

Now let's create a minimal gRPC server to understand the fundamentals.

File: cmd/server/main.go

package main

import (
    "log"
    "net"

    pb "github.com/yourusername/grpc-hexagonal-demo/pkg/protos"
    "google.golang.org/grpc"
)

func main() {
    // Create a TCP listener on port 50051
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    // Create a new gRPC server
    s := grpc.NewServer()

    // TODO: Register our calculator service here
    // pb.RegisterCalculatorServer(s, &services.CalculatorServer{})

    log.Println("gRPC server running on port 50051...")

    // Start serving requests
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Understanding the code:

If you're familiar with creating HTTP servers in Go, this should look similar:

Create a TCP listener on port 50051
Create a gRPC server instance
Register services (we'll do this next)
Start serving requests

At this point, the server will start but won't handle any requests because we haven't implemented the service methods yet.

Implementing the Calculator Service

Let's implement the actual business logic for our calculator operations.

File: internal/services/calculator.go

package services

import (
    "context"
    "errors"

    pb "github.com/yourusername/grpc-hexagonal-demo/pkg/protos"
)

// CalculatorServer implements the Calculator gRPC service
type CalculatorServer struct {
    pb.UnimplementedCalculatorServer
}

// NewCalculatorServer creates a new calculator server instance
func NewCalculatorServer() *CalculatorServer {
    return &CalculatorServer{}
}

// Add implements the Add RPC method
func (c *CalculatorServer) Add(ctx context.Context, req *pb.OperationRequest) (*pb.OperationResponse, error) {
    result := req.A + req.B
    return &pb.OperationResponse{
        Result: result,
    }, nil
}

// Multiply implements the Multiply RPC method
func (c *CalculatorServer) Multiply(ctx context.Context, req *pb.OperationRequest) (*pb.OperationResponse, error) {
    result := req.A * req.B
    return &pb.OperationResponse{
        Result: result,
    }, nil
}

// Divide implements the Divide RPC method
func (c *CalculatorServer) Divide(ctx context.Context, req *pb.OperationRequest) (*pb.OperationResponse, error) {
    if req.B == 0 {
        return nil, errors.New("cannot divide by zero")
    }

    result := req.A / req.B
    return &pb.OperationResponse{
        Result: result,
    }, nil
}

Key points:

UnimplementedCalculatorServer: Embedding this ensures forward compatibility if new methods are added to the proto
Context parameter: Used for cancellation, deadlines, and request-scoped values
Error handling: The Divide method demonstrates proper error handling (division by zero)
Each method returns a pointer to OperationResponse

Registering the Service

Update cmd/server/main.go to register our calculator service:

package main

import (
    "log"
    "net"

    "github.com/yourusername/grpc-hexagonal-demo/internal/services"
    pb "github.com/yourusername/grpc-hexagonal-demo/pkg/protos"
    "google.golang.org/grpc"
)

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }

    s := grpc.NewServer()

    // Register the calculator service
    calcServer := services.NewCalculatorServer()
    pb.RegisterCalculatorServer(s, calcServer)

    log.Println("gRPC server running on port 50051...")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Run your server:

task run
# or
go run cmd/server/main.go

You should see: gRPC server running on port 50051...

Testing with Postman

Postman has excellent support for gRPC, making it easy to test your services.

Setting Up gRPC in Postman

Create a new request and select gRPC as the protocol
Enter the server URL: localhost:50051
Import your proto file: Click "Select a method" → "Import .proto file" → Navigate to pkg/protos/calculator.proto
Select a method: Choose Calculator.Add, Calculator.Multiply, or Calculator.Divide

Making a Request

For the Add method:

Request:

{
  "a": 5,
  "b": 3
}

Response:

{
  "result": 8
}

Try the same for Multiply and Divide to verify all methods work correctly.

What Just Happened?

Postman read the protobuf contract to understand available methods and their signatures
It constructed a valid gRPC request with the data you provided
Your server received the request, called the appropriate method, and returned the result
Postman decoded the binary response and displayed it as JSON

Without the contract, the client wouldn't know what methods exist or what data to send. This is the power of contract-first development with gRPC.

Understanding Dependency Injection (DI)

Before diving into Hexagonal Architecture, we need to understand Dependency Injection because DI is what makes hexagonal architecture flexible, testable, and maintainable.

What is Dependency Injection?

Dependency Injection is a design pattern where:

A component does not create the things it depends on those dependencies are provided to it from the outside.

Why DI Matters

Without DI, your code becomes tightly coupled:

Handlers create services
Services create repositories
Repositories create database clients
Everything is hard-coded and nearly impossible to unit test

With DI, you gain:

✅ Flexibility: Replace implementations easily
✅ Testability: Mock dependencies in unit tests
✅ Clarity: Dependencies are explicit and visible
✅ Maintainability: Changes to one component don't cascade everywhere

Example: Bad (Non-DI) Code

type UserService struct {
    repo *PostgresRepo
}

func NewUserService() *UserService {
    return &UserService{
        repo: NewPostgresRepo(), // Tightly coupled!
    }
}

Problems:

The service is hard-wired to PostgreSQL
You can't test without a real database
Switching to MySQL or MongoDB requires code changes throughout

Example: Good (DI-Friendly) Code

type UserRepository interface {
    FindByID(id string) (*User, error)
    Save(user *User) error
}

type UserService struct {
    repo UserRepository
}

func NewUserService(repo UserRepository) *UserService {
    return &UserService{
        repo: repo,
    }
}

Benefits:

Now you can plug in:
- PostgresRepo for production
- MySQLRepo for a different deployment
- InMemoryRepo for tests
- MockRepo for unit tests

The Dependency Problem at Scale

For small apps, manual wiring is manageable:

func main() {
    db := NewPostgresDB()
    repo := NewPostgresRepo(db)
    svc := NewUserService(repo)
    handler := NewGRPCHandler(svc)
    server := NewGRPCServer(handler)
    server.Start()
}

But in real microservices with dozens of dependencies:

Manual wiring becomes error-prone
Initialization order matters
Lifecycle management (startup/shutdown) is complex
Circular dependencies are hard to detect

This is where Uber Fx comes in.

Introducing Uber Fx for Dependency Injection

Uber Fx is a dependency injection framework for Go that automates the wiring of your application's dependencies.

What Fx Provides

✅ Automatic dependency graph building: Fx figures out the correct initialization order
✅ Missing dependency detection: Fails fast if dependencies are missing
✅ Lifecycle management: Clean startup and shutdown hooks
✅ Constructor validation: Ensures all dependencies can be satisfied at compile time (with proper setup)

How Fx Works

You declare providers (constructors) and invokers (startup functions), and Fx does the rest:

fx.New(
    fx.Provide(
        NewDatabase,      // Provides *Database
        NewRepository,    // Provides *Repository (needs *Database)
        NewService,       // Provides *Service (needs *Repository)
        NewHandler,       // Provides *Handler (needs *Service)
    ),
    fx.Invoke(StartServer), // Starts the server (needs *Handler)
)

Fx automatically:

Calls constructors in the correct order
Passes dependencies to each constructor
Invokes startup functions with all dependencies satisfied
Manages graceful shutdown

Visualizing the Dependency Graph

Here's how Fx wires our calculator service:

graph LR
    subgraph "Fx Providers"
        P1[NewInMemoryRepo]
        P2[NewCalculatorService]
        P3[NewCalculatorHandler]
        P4[NewGRPCServer]
    end

    subgraph "Dependencies"
        D1[Repository]
        D2[CalculatorPort]
        D3[Handler]
        D4[Server]
    end

    subgraph "Invoker"
        I1[RegisterServer]
    end

    P1 -->|provides| D1
    P2 -->|needs D1, provides| D2
    P3 -->|needs D2, provides| D3
    P4 -->|provides| D4

    D3 -->|used by| I1
    D4 -->|used by| I1

    I1 -->|starts| SERVER[gRPC Server :50051]

    style P1 fill:#FFC107,stroke:#F57F17,stroke-width:2px
    style P2 fill:#FFC107,stroke:#F57F17,stroke-width:2px
    style P3 fill:#FFC107,stroke:#F57F17,stroke-width:2px
    style P4 fill:#FFC107,stroke:#F57F17,stroke-width:2px
    style I1 fill:#E91E63,stroke:#880E4F,stroke-width:2px,color:#fff
    style SERVER fill:#4CAF50,stroke:#1B5E20,stroke-width:3px,color:#fff

Key:

🟡 Yellow: Providers (constructors)
🔵 Blue: Created dependencies
🔴 Pink: Invoker (startup function)
🟢 Green: Running server

Hexagonal Architecture + Uber Fx + gRPC

Now we combine everything into a clean, maintainable architecture.

Understanding Hexagonal Architecture

Hexagonal Architecture (also known as Ports and Adapters) separates your application into three main layers:

1. Domain Layer (Core)

The heart of your application:

Pure business logic: No external dependencies
Domain entities: Your core data structures
Ports (interfaces): Define contracts for external interactions
No framework code: Could theoretically run in any environment

2. Adapters Layer

Implementations that connect your domain to the outside world:

Driving adapters (inbound): gRPC handlers, HTTP controllers, CLI commands
Driven adapters (outbound): Database repositories, external API clients, message queues

3. Application Layer

The glue that wires everything together:

Dependency injection setup (Fx modules)
Configuration management
Application lifecycle

Visualizing Hexagonal Architecture

Here's how the layers interact in our calculator service:

graph TB
    subgraph "Driving Adapters (Inbound)"
        A1[gRPC Handler]
    end

    subgraph "Domain Core (Business Logic)"
        P1[Ports/Interfaces]
        S1[Calculator Service]
    end

    subgraph "Driven Adapters (Outbound)"
        D1[Repository]
    end

    A1 -->|depends on| P1
    P1 -.implements.- S1
    S1 -->|depends on| P1
    P1 -.implements.- D1

    style P1 fill:#4CAF50,stroke:#2E7D32,stroke-width:3px,color:#fff
    style S1 fill:#2196F3,stroke:#1565C0,stroke-width:2px,color:#fff
    style A1 fill:#FF9800,stroke:#E65100,stroke-width:2px,color:#fff
    style D1 fill:#9C27B0,stroke:#4A148C,stroke-width:2px,color:#fff

Key principles:

🟢 Green (Ports): Pure interfaces that define contracts
🔵 Blue (Domain): Business logic with no external dependencies
🟠 Orange (Driving): Inbound adapters that trigger use cases
🟣 Purple (Driven): Outbound adapters that provide infrastructure

Project Structure with Hexagonal Architecture

grpc-hexagonal-demo/
├── cmd/
│   └── server/
│       └── main.go          # Entry point
├── internal/
│   ├── app/                 # Fx modules and wiring
│   │   └── modules.go
│   ├── domain/              # Core business logic
│   │   ├── entities.go      # Domain entities
│   │   └── ports.go         # Interface definitions
│   ├── services/            # Domain service implementations
│   │   └── calculator_service.go
│   └── adapters/
│       ├── grpc/            # gRPC handlers (driving adapter)
│       │   └── calculator_handler.go
│       └── db/              # Repository implementations (driven adapter)
│           └── calculator_repo.go
├── pkg/
│   └── protos/
│       └── calculator.proto
├── go.mod
└── Taskfile.yml

Implementing Hexagonal Architecture: Step by Step

Step 1: Define Ports (Domain Interfaces)

The domain defines what it needs, not how it's implemented.

File: internal/domain/ports.go

package domain

// CalculatorPort defines the business operations our domain provides
type CalculatorPort interface {
    Add(a, b float32) float32
    Multiply(a, b float32) float32
    Divide(a, b float32) (float32, error)
}

Key points:

This is your core contract
No implementation details
No external dependencies
Your gRPC layer will depend on this interface, not concrete implementations

Step 2: Implement the Domain Service

File: internal/services/calculator_service.go

package services

import (
    "errors"

    "github.com/yourusername/grpc-hexagonal-demo/internal/domain"
)

// CalculatorService implements domain.CalculatorPort
type CalculatorService struct{}

// NewCalculatorService creates a new calculator service
func NewCalculatorService() domain.CalculatorPort {
    return &CalculatorService{}
}

func (c *CalculatorService) Add(a, b float32) float32 {
    return a + b
}

func (c *CalculatorService) Multiply(a, b float32) float32 {
    return a * b
}

func (c *CalculatorService) Divide(a, b float32) (float32, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

Notice:

✅ No gRPC code here
✅ No database code here
✅ Pure business logic
✅ Returns the interface type from the constructor

This is the essence of clean architecture: the domain knows nothing about delivery mechanisms or infrastructure.

Request Flow Visualization

Let's trace a request through our hexagonal architecture:

sequenceDiagram
    participant C as Client (Postman)
    participant G as gRPC Handler
    participant P as CalculatorPort
    participant S as CalculatorService
    participant R as Repository

    C->>G: Calculator.Add(a=5, b=3)
    Note over G: Adapter convertsgRPC to domain

    G->>P: Add(5, 3)
    Note over P: Interface/Port

    P->>S: Add(5, 3)
    Note over S: Business logica + b = 8

    S->>R: Save(history)
    Note over R: Store calculation
    R-->>S: ✓

    S-->>P: 8
    P-->>G: 8

    Note over G: Adapter convertsdomain to gRPC
    G-->>C: OperationResponse{result: 8}

    Note over C,R: 🎯 Key insight: Domain (S) never knows about gRPC or storage

Notice how:

The handler translates between gRPC and domain types
The service only works with pure Go types (float32)
The repository is just an interface to the service
Each layer has a single, clear responsibility

Step 3: Implement the gRPC Adapter (Driving)

The gRPC adapter translates between the gRPC protocol and our domain.

File: internal/adapters/grpc/calculator_handler.go

package grpc

import (
    "context"

    pb "github.com/yourusername/grpc-hexagonal-demo/pkg/protos"
    "github.com/yourusername/grpc-hexagonal-demo/internal/domain"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
)

// CalculatorHandler is a gRPC adapter for the calculator service
type CalculatorHandler struct {
    pb.UnimplementedCalculatorServer
    svc domain.CalculatorPort
}

// NewCalculatorHandler creates a new gRPC calculator handler
func NewCalculatorHandler(svc domain.CalculatorPort) *CalculatorHandler {
    return &CalculatorHandler{
        svc: svc,
    }
}

// Add handles the Add RPC
func (h *CalculatorHandler) Add(ctx context.Context, req *pb.OperationRequest) (*pb.OperationResponse, error) {
    result := h.svc.Add(req.A, req.B)
    return &pb.OperationResponse{Result: result}, nil
}

// Multiply handles the Multiply RPC
func (h *CalculatorHandler) Multiply(ctx context.Context, req *pb.OperationRequest) (*pb.OperationResponse, error) {
    result := h.svc.Multiply(req.A, req.B)
    return &pb.OperationResponse{Result: result}, nil
}

// Divide handles the Divide RPC
func (h *CalculatorHandler) Divide(ctx context.Context, req *pb.OperationRequest) (*pb.OperationResponse, error) {
    result, err := h.svc.Divide(req.A, req.B)
    if err != nil {
        return nil, status.Errorf(codes.InvalidArgument, err.Error())
    }
    return &pb.OperationResponse{Result: result}, nil
}

Key observations:

✅ The handler depends on the interface, not the concrete implementation
✅ It translates gRPC requests/responses to domain calls
✅ It handles gRPC-specific error codes
✅ This is the only place that knows about gRPC

Step 4: Wire Everything with Uber Fx

Now let's bring it all together using Fx.

First, install Fx:

go get go.uber.org/fx

File: internal/app/modules.go

package app

import (
    "context"
    "net"

    "go.uber.org/fx"
    "google.golang.org/grpc"

    "github.com/yourusername/grpc-hexagonal-demo/internal/services"
    grpcHandler "github.com/yourusername/grpc-hexagonal-demo/internal/adapters/grpc"
    pb "github.com/yourusername/grpc-hexagonal-demo/pkg/protos"
)

// Module contains all application dependencies
var Module = fx.Options(
    fx.Provide(
        // Domain layer
        services.NewCalculatorService,

        // Adapter layer
        grpcHandler.NewCalculatorHandler,

        // Infrastructure
        NewGRPCServer,
    ),
    fx.Invoke(RegisterServer),
)

// NewGRPCServer creates a new gRPC server instance
func NewGRPCServer() *grpc.Server {
    return grpc.NewServer()
}

// RegisterServer registers all gRPC services and starts the server
func RegisterServer(
    lc fx.Lifecycle,
    server *grpc.Server,
    handler *grpcHandler.CalculatorHandler,
) {
    // Register the calculator handler
    pb.RegisterCalculatorServer(server, handler)

    lc.Append(fx.Hook{
        OnStart: func(ctx context.Context) error {
            lis, err := net.Listen("tcp", ":50051")
            if err != nil {
                return err
            }

            go func() {
                if err := server.Serve(lis); err != nil {
                    panic(err)
                }
            }()

            println("gRPC server started on :50051")
            return nil
        },
        OnStop: func(ctx context.Context) error {
            println("Gracefully stopping gRPC server...")
            server.GracefulStop()
            return nil
        },
    })
}

Understanding the code:

fx.Provide: Declares constructors that Fx should call
fx.Invoke: Declares functions that should run at startup
fx.Lifecycle: Manages application startup and shutdown
OnStart hook: Starts the gRPC server in a goroutine
OnStop hook: Gracefully stops the server on shutdown

Complete System Visualization

Here's everything wired together:

graph TB
    subgraph "Client"
        CLIENT[Postman/grpcurl]
    end

    subgraph "Infrastructure (Fx)"
        FX[Fx Container]
        LC[Lifecycle Manager]
    end

    subgraph "Adapters"
        GRPC[gRPC Handler:50051]
        REPO[Repository]
    end

    subgraph "Domain"
        PORT_IN[CalculatorPort]
        PORT_OUT[CalcRepository]
        SVC[CalculatorService]
    end

    subgraph "Contract"
        PROTO[calculator.proto]
    end

    CLIENT -->|gRPC Request| GRPC
    GRPC -.uses.- PROTO

    FX -->|provides| GRPC
    FX -->|provides| SVC
    FX -->|provides| REPO

    GRPC -->|depends on| PORT_IN
    PORT_IN -.implemented by.- SVC

    SVC -->|depends on| PORT_OUT
    PORT_OUT -.implemented by.- REPO

    LC -->|manages| GRPC

    style FX fill:#2196F3,stroke:#0D47A1,stroke-width:3px,color:#fff
    style LC fill:#2196F3,stroke:#0D47A1,stroke-width:2px,color:#fff
    style GRPC fill:#FF9800,stroke:#E65100,stroke-width:2px,color:#fff
    style REPO fill:#9C27B0,stroke:#4A148C,stroke-width:2px,color:#fff
    style PORT_IN fill:#4CAF50,stroke:#2E7D32,stroke-width:3px,color:#fff
    style PORT_OUT fill:#4CAF50,stroke:#2E7D32,stroke-width:3px,color:#fff
    style SVC fill:#2196F3,stroke:#1565C0,stroke-width:2px,color:#fff

What's happening:

🔵 Fx builds all dependencies in the correct order
🟢 Ports (interfaces) keep everything decoupled
🟠 gRPC handler only knows about the port, not the implementation
🟣 Repository implements a port, can be swapped easily
🔵 Lifecycle manager handles clean startup/shutdown

Step 5: Update main.go

File: cmd/server/main.go

package main

import (
    "go.uber.org/fx"

    "github.com/yourusername/grpc-hexagonal-demo/internal/app"
)

func main() {
    fx.New(
        app.Module,
    ).Run()
}

That's it! Just 7 lines of code in main.go.

Fx automatically:

✅ Builds the dependency graph
✅ Initializes all components in the correct order
✅ Starts the server
✅ Handles graceful shutdown (Ctrl+C)

Running and Testing the Complete Application

Start the Server

task run

You should see:

[Fx] PROVIDE    *services.CalculatorService <= services.NewCalculatorService()
[Fx] PROVIDE    *grpc.CalculatorHandler <= grpc.NewCalculatorHandler()
[Fx] PROVIDE    *grpc.Server <= app.NewGRPCServer()
[Fx] INVOKE     app.RegisterServer()
gRPC server started on :50051
[Fx] RUNNING

Test with Postman

Create a new gRPC request
Connect to localhost:50051
Import pkg/protos/calculator.proto
Test each method:

Calculator.Add:

Request:  {"a": 10, "b": 5}
Response: {"result": 15}

Calculator.Multiply:

Request:  {"a": 7, "b": 8}
Response: {"result": 56}

Calculator.Divide:

Request:  {"a": 20, "b": 4}
Response: {"result": 5}

Request:  {"a": 10, "b": 0}
Error:    "cannot divide by zero"

Benefits of This Architecture

Let's see why this architectural approach is worth the effort.

Architectural Comparison

Traditional Approach (Tightly Coupled)

graph TD
    H[HTTP Handler]
    S[Service]
    P[PostgreSQL Client]

    H -->|directly creates| S
    S -->|directly creates| P

    style H fill:#FF5252,stroke:#C62828,stroke-width:2px,color:#fff
    style S fill:#FF5252,stroke:#C62828,stroke-width:2px,color:#fff
    style P fill:#FF5252,stroke:#C62828,stroke-width:2px,color:#fff

Problems:

❌ Can't test service without a real database
❌ Can't switch databases without rewriting service code
❌ Can't add gRPC without major refactoring
❌ Service knows about HTTP, database, and business logic

Hexagonal Approach (Decoupled)

graph TD
    H1[HTTP Handler]
    H2[gRPC Handler]
    PORT[CalculatorPort Interface]
    S[Service]
    PORT2[Repository Interface]
    P1[PostgreSQL]
    P2[MongoDB]
    M[Mock for Tests]

    H1 -->|depends on| PORT
    H2 -->|depends on| PORT
    PORT -.implemented by.- S

    S -->|depends on| PORT2
    PORT2 -.implemented by.- P1
    PORT2 -.implemented by.- P2
    PORT2 -.implemented by.- M

    style H1 fill:#4CAF50,stroke:#1B5E20,stroke-width:2px,color:#fff
    style H2 fill:#4CAF50,stroke:#1B5E20,stroke-width:2px,color:#fff
    style PORT fill:#2196F3,stroke:#0D47A1,stroke-width:3px,color:#fff
    style S fill:#4CAF50,stroke:#1B5E20,stroke-width:2px,color:#fff
    style PORT2 fill:#2196F3,stroke:#0D47A1,stroke-width:3px,color:#fff
    style P1 fill:#4CAF50,stroke:#1B5E20,stroke-width:2px,color:#fff
    style P2 fill:#4CAF50,stroke:#1B5E20,stroke-width:2px,color:#fff
    style M fill:#FFC107,stroke:#F57F17,stroke-width:2px

Benefits:

✅ Easy to test with mocks
✅ Easy to switch databases (just change wiring)
✅ Easy to add new adapters (HTTP, gRPC, CLI)
✅ Service only knows about business logic

1. Testability

You can now easily unit test your domain logic without gRPC or any infrastructure:

func TestCalculatorService_Add(t *testing.T) {
    svc := services.NewCalculatorService()

    result := svc.Add(5, 3)

    if result != 8 {
        t.Errorf("expected 8, got %f", result)
    }
}

2. Flexibility

Want to add an HTTP REST API alongside gRPC? Just create a new adapter:

// internal/adapters/http/calculator_handler.go
type CalculatorHTTPHandler struct {
    svc domain.CalculatorPort
}

func (h *CalculatorHTTPHandler) Add(w http.ResponseWriter, r *http.Request) {
    // Parse request, call h.svc.Add(), return JSON
}

3. Maintainability

Domain changes don't affect adapters
gRPC changes don't affect the domain
Adding features means implementing the interface and wiring it up

4. Clear Dependencies

Looking at the Fx module tells you exactly what your application needs:

fx.Provide(
    services.NewCalculatorService,     // Domain
    grpcHandler.NewCalculatorHandler,  // Adapter
    NewGRPCServer,                     // Infrastructure
)

Advanced: Adding a Database Repository

Let's extend our architecture to include a database for storing calculation history.

Step 1: Define the Repository Port

File: internal/domain/ports.go

package domain

type CalculationHistory struct {
    ID        string
    Operation string
    A         float32
    B         float32
    Result    float32
}

// CalculationRepository defines how we store calculation history
type CalculationRepository interface {
    Save(history CalculationHistory) error
    FindAll() ([]CalculationHistory, error)
}

Step 2: Update the Service to Use the Repository

File: internal/services/calculator_service.go

package services

import (
    "errors"

    "github.com/yourusername/grpc-hexagonal-demo/internal/domain"
)

type CalculatorService struct {
    repo domain.CalculationRepository
}

func NewCalculatorService(repo domain.CalculationRepository) domain.CalculatorPort {
    return &CalculatorService{
        repo: repo,
    }
}

func (c *CalculatorService) Add(a, b float32) float32 {
    result := a + b

    // Save to history
    c.repo.Save(domain.CalculationHistory{
        Operation: "add",
        A:         a,
        B:         b,
        Result:    result,
    })

    return result
}

// ... similar for Multiply and Divide

Step 3: Implement an In-Memory Repository

File: internal/adapters/db/memory_repo.go

package db

import (
    "sync"

    "github.com/yourusername/grpc-hexagonal-demo/internal/domain"
)

type InMemoryRepo struct {
    mu      sync.RWMutex
    history []domain.CalculationHistory
}

func NewInMemoryRepo() domain.CalculationRepository {
    return &InMemoryRepo{
        history: make([]domain.CalculationHistory, 0),
    }
}

func (r *InMemoryRepo) Save(calc domain.CalculationHistory) error {
    r.mu.Lock()
    defer r.mu.Unlock()

    r.history = append(r.history, calc)
    return nil
}

func (r *InMemoryRepo) FindAll() ([]domain.CalculationHistory, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()

    return r.history, nil
}

Step 4: Wire It All Together

File: internal/app/modules.go

var Module = fx.Options(
    fx.Provide(
        // Driven adapters (repositories)
        db.NewInMemoryRepo,

        // Domain layer
        services.NewCalculatorService,

        // Driving adapters (handlers)
        grpcHandler.NewCalculatorHandler,

        // Infrastructure
        NewGRPCServer,
    ),
    fx.Invoke(RegisterServer),
)

That's it! Fx automatically wires the repository into the service.

Later, you can replace InMemoryRepo with PostgresRepo or MongoRepo without touching the domain logic.

Production Considerations

Configuration Management

Use environment variables or config files:

type Config struct {
    GRPCPort string
    DBUrl    string
}

func NewConfig() *Config {
    return &Config{
        GRPCPort: os.Getenv("GRPC_PORT"),
        DBUrl:    os.Getenv("DATABASE_URL"),
    }
}

// In Fx module
fx.Provide(NewConfig)

Logging

Add structured logging with zap:

import "go.uber.org/zap"

fx.Provide(
    zap.NewProduction, // or zap.NewDevelopment
)

func NewCalculatorService(logger *zap.Logger, repo domain.CalculationRepository) domain.CalculatorPort {
    return &CalculatorService{
        logger: logger,
        repo:   repo,
    }
}

Middleware

Add interceptors for authentication, logging, etc.:

func NewGRPCServer(logger *zap.Logger) *grpc.Server {
    return grpc.NewServer(
        grpc.ChainUnaryInterceptor(
            LoggingInterceptor(logger),
            AuthInterceptor(),
        ),
    )
}

Health Checks

Implement gRPC health checks:

import "google/health/v1/health.proto";

Conclusion

In this comprehensive tutorial, we've covered:

✅ gRPC fundamentals: Protocol Buffers, RPC methods, and efficient service communication

✅ Dependency Injection with Uber Fx: Automatic dependency graph building and lifecycle management

✅ Hexagonal Architecture: Clean separation between domain, adapters, and infrastructure

✅ Production-ready patterns: Testability, flexibility, and maintainability

Key Takeaways

gRPC provides fast, type-safe communication between services using Protocol Buffers and HTTP/2
Dependency Injection decouples components and makes testing straightforward
Hexagonal Architecture keeps business logic pure and independent of delivery mechanisms
Uber Fx automates the tedious work of wiring dependencies

Next Steps

Add more operations (subtraction, exponentiation, etc.)
Implement a PostgreSQL repository
Add authentication and authorization
Create comprehensive unit and integration tests
Add metrics and distributed tracing
Deploy to Kubernetes

Resources

You now have a solid foundation for building scalable, maintainable microservices in Go! The patterns you've learned here will serve you well in production environments.

Happy coding! 🚀

Demystifying Docker Containers: Unleashing the Magic of Self-Contained Application Packages

Sylvester Asare Sarpong — Thu, 22 Jun 2023 21:50:41 +0000

I have watched countless videos and read numerous articles attempting to explain what Docker is, but each time I think I understand Docker containers, I become even more confused. In this post, I will attempt to break down Docker containers into simpler terms that we can all understand.

Imagine the image above is the installation folder for Tom Clancy's Splinter Cell video game, a great game by the way(you should check it out after this post). Most installation folders follow a similar structure, with a main setup file and additional binaries and libraries required for installation. However, there's a catch – your computer might not meet the minimum requirements to play the game, preventing you from enjoying it. But what if there was a way to simply download the game, start playing it right away, and not have to go through the installation process or worry about meeting system requirements?

That's where Docker containers come in. In essence, Docker containers are like magical boxes that not only contain the entire game but also ensure that it already meets all the necessary requirements for running. Thinking in terms of Docker and the video game analogy, you can imagine this box as a self-contained package that has the game installed and configured perfectly inside it. The beauty of it is that because the game within the box already meets all the requirements, you can just run it on your personal computer without having to worry about compatibility or system requirements. All the container needs is access to the underlying kernel of your operating system to make the magic happen.

In the context of Docker containers, they are also like these magical boxes. Docker containers are self-contained packages that encapsulate an application and all its dependencies. They include everything needed for the application to run, such as libraries, binaries, and configuration files. These containers run independently from your host machine, utilizing the underlying kernel of your operating system to access the necessary resources. By utilizing the host kernel and not requiring their own separate operating system, Docker containers are lightweight and fast to start up.

With Docker containers, you can package applications in a consistent and portable manner, making them easily deployable across different environments. Just like the game within the magical box, Docker containers provide a reliable and self-contained runtime environment for applications, ensuring consistent behavior regardless of the underlying host machine. They offer the convenience of being able to download and run applications without the need for complex installation processes or concerns about system compatibility.

Spread Them: Leveraging the Spread Operator for Safer State Updates in React

Sylvester Asare Sarpong — Tue, 20 Jun 2023 05:50:52 +0000

You have seen state being updated like this, but have you ever wondered why it has become the convention that everyone uses?

setPerson((prevPerson) => ({ ...prevPerson, name: "Jane Doe" }));

State management is crucial in React applications for maintaining a predictable and reliable user interface. Proper handling of state updates is essential, and using the spread operator instead of directly modifying the state is a recommended best practice. But why is it so widely adopted? In this post, we will explore the benefits of using the spread operator for state updates, demonstrate its usage, and discuss the advantages it offers over direct state mutation.

React utilizes shallow comparison to determine whether a state has changed. Shallow comparison checks the reference of items in an object without recursively checking their values. While this approach is efficient and works well for primitive types like strings and numbers, it can be problematic when dealing with complex data types such as objects.

Let's consider an example to illustrate this point:

const [person, setPerson] = useState({
    id: 1,
    name: "John Doe",
});

let temp = person;
temp.name = "Jane Doe";
setPerson(temp);

In the code above, the person state is directly modified by assigning it to the temp variable and updating the name property. Although this approach may seem to work initially, it violates the principle of immutability, which is central to React's state management philosophy. React relies on the assumption that state is immutable to perform accurate state comparisons during the reconciliation process.

To update the state correctly and adhere to immutability principles, we need to create a new object that maintains the integrity of the original state. This is where the spread operator comes into play:

setPerson((prevPerson) => ({ ...prevPerson, name: "Jane Doe" }));

The correct approach is to use the functional form of the setPerson function, providing a callback that receives the previous state as prevPerson. By spreading the prevPerson, we create a shallow copy of the state object. Then, we modify the desired property (name) of the copied state object and pass it as the argument to setPerson. This ensures that React can accurately detect the state change and trigger the necessary updates.

Using the spread operator allows us to create copies of objects or arrays by value, ensuring that any changes made to the copy do not affect the original state. This approach maintains immutability and enables React's shallow comparison algorithm to accurately compare the state.

One might wonder why we don't use deep comparison instead of shallow comparison, making it necessary to explicitly manage immutability. While deep comparison checks the values of each item in the state recursively, it can be expensive, especially for complex data types. React decided to provide something better than the default JavaScript comparison and less expensive than deep comparison.

To summarize, updating state in React using the spread operator is a best practice that promotes immutability and enables efficient state comparisons. By creating new copies of state objects and modifying those copies, we ensure the integrity of the state and facilitate reliable state management within React applications.

So next time you update state in React, remember to embrace the spread operator and enjoy the benefits it brings to your state management journey.

Creating and Publishing a VS Code Extension: A Step-by-Step Guide with JavaScript

Sylvester Asare Sarpong — Fri, 24 Feb 2023 01:44:24 +0000

I recently stumbled upon a unique and entertaining extension for VS Code called vscode-pets, created by Anthony Shaw. This extension adds a virtual pet, such as a dog🐶, to your screen, providing a fun distraction from coding. However, there are many other pet options to choose from.

VS Code extensions are plugins that can enhance your coding experience with the Visual Studio Code editor. They offer a range of features, including syntax highlighting, code formatting, debugging, testing, linting, snippets, themes, icons, and more. VS Code is designed with extensibility in mind, making it easy to personalize and tailor to your needs. The VS Code marketplace currently offers over 30,000 extensions, spanning from language and theme extensions to integration extensions and even fun and whimsical options.

To begin creating your own VS Code extension, you will need to have Node.js installed on your system. Once you have Node.js set up, you can use a command-line tool called yo (short for Yeoman) to generate a project template. This template will provide you with a basic structure and files for your extension, including a manifest file that defines the extension's metadata and dependencies. You can then customize and build on this template to create your desired functionality.

The Problem

React is my favorite JavaScript framework because of its versatility and powerful features. However, sometimes creating component state in React can be a bit of a hassle and require a lot of typing. In today's post, we will be addressing this issue and exploring ways to make this process less tedious. While we won't be attempting to fix the entire framework, we will be creating an extension that can simplify the creation of state in React components.

const [counter, setCounter] = useState(0);

Creating a simple counter state in React can involve a lot of typing, which can be tedious and time-consuming. We all know how exhausting it can be to type out the same code repeatedly, right? That's where our new extension, react-setstate, comes in. With this extension, we can create state variables in just a few keystrokes, saving us time and effort.

Setting Up the Development Environment

To get started with creating a Visual Studio Code extension, we will need to install two packages - yo and generator-code. These can be installed globally using npm with the following command:

npm install -g yo generator-code

yo is a popular scaffolding tool that helps developers generate new projects by using customizable generators. generator-code is a generator specifically designed for creating Visual Studio Code extensions. By installing these two packages, we will be able to quickly generate a new extension project and get started with coding right away!

Now that we have installed the necessary packages, we can start creating our project. To do this, open up your terminal and run the following command:

yo code

This will launch an interactive shell that will guide us through the process of creating our new extension. We will be prompted to enter various details about our extension, such as its name, description, and the type of extension we want to create. By following the prompts and answering the questions, we will be able to quickly generate the scaffolding for our new extension and start building our code.

     _-----_     ╭──────────────────────────╮
    |       |    │   Welcome to the Visual  │
    |--(o)--|    │   Studio Code Extension  │
   `---------´   │        generator!        │
    ( _´U`_ )    ╰──────────────────────────╯
    /___A___\   /
     |  ~  |
   __'.___.'__
 ´   `  |° ´ Y `

? What type of extension do you want to create? New Extension (JavaScript)
? What's the name of your extension? react-setstate
? What's the identifier of your extension? react-setstate
? What's the description of your extension? set state in react
? Enable JavaScript type checking in 'jsconfig.json'? No
? Initialize a git repository? Yes
? Which package manager to use? npm

Once we have answered all the prompts in the yo interactive shell, it will generate a new project for us based on our inputs. We can open this project in Visual Studio Code by navigating to its directory in the terminal and running the following command:

code .

Anatomy of the project.

Our project structure should look something like this, you might have some additional files if you selected TypeScript. We will go over all the files and explain why they are present.

├── .vscode // launch a new window for testing 
│   ├── launch.json    
│   └── tasks.json 
├── node_modules  //node_modules
├── test //tests
│   ├──  suite
│   ├── ├── extension.test.js       
│   └── runTest.js     
├── .eslintrc.json // ESLint config
├── .gitignore //ignore node_modules and other specified files
├── .vscodeignore   //ignore files we don't have published
├── CHANGELOG.md //keep track of changes
├── extension.js //source code
├── jsconfig.json   //JS config  
├── package-lock.json //generated by npm   
├── package.json //manifest    
├── README.md  //info about extension
├── vsc-extension-quickstart.md //quick start guide

The launch.json and the tasks.json are used to launch a new window of VS code for testing the extension.
node_modules - node_modules for our project.
The test folder will contain all the tests for our extension.
.eslintrc.json will contain ESLint configuration for this project.
.gitignore will contain a list of names of files and/or folders that we don't to be included when you push our extension to version control platform like Github.
.vscodeignore will contain a list of names of files and/or folders that should be published when we finally publish our extension.
CHANGELOG.md will be used to keep track of changes we make to our extension.
extension.js this is where we will be writing the code/logic behind our extension(entry point).
jsconfig.json will contain our Javascript configuration
package.json is the manifest file of any Node.js project and contains the metadata of the project.
README.md will contain the info about our extension.
vsc-extension-quickstart.md is the default quick start guide that comes with our project.

Entry Point

Open extension.js file, which contains boilerplate code and comments. Let's briefly understand the code before we proceed to clean it up.

const vscode = require('vscode');

Imports the vscode extensibility API module.

function activate(context) {

    console.log('Congratulations, your extension "react-setstate" is now active!');

    let disposable = vscode.commands.registerCommand('react-setstate.helloWorld', function () {

        vscode.window.showInformationMessage('Hello World from react-setstate!');
    });

    context.subscriptions.push(disposable);
}

The above is the activate function which get call when our extenison is activated.

let disposable = vscode.commands.registerCommand('react-setstate.helloWorld', function () {

        vscode.window.showInformationMessage('Hello World from react-setstate!');
    });

The react-setstate.helloWorld is a unique identifier for a command that performs a specific action when triggered. For instance, when the react-setstate.helloWorld command is invoked, it shows a message displaying "Hello World from react-setstate!". However, command IDs can be lengthy, and typing them out every time can be tedious. Therefore, we can assign simpler names to these command IDs for ease of use

package.json

In the package.json file, under the contributes field, there is an array called commands which includes the default command ID. By default, the title of the react-setstate.helloWorld command has been set to something memorable, "Hello World". Any new command IDs we register can be added to this array. To run our extension, we can press Ctrl + F5, which will open a new VS Code window with the name "[Extension Development Host]". To launch our extension, we can press Ctrl + Shift + P to open the command palette, type in the name we gave the extension (in this case, "Hello World"), and press Enter.

This will launch our extension

We can stop the Extension Development Host by pressing the red square.

extension.js

This tutorial has become quite lengthy, so to save time, I'll paste the code and then explain what each part does.


const vscode = require('vscode');

/**
 * @param {vscode.ExtensionContext} context
 */
function activate(context) {
    let disposable = vscode.commands.registerCommand('react-setstate.setState', async function () {
        const inputText = await vscode.window.showInputBox({
            placeHolder: "Eg: show modal",
            prompt: "Enter the name of your state.",
          });

          if (inputText === "") {
            vscode.window.showErrorMessage(
              "You need to type in something for this to work😊."
            );
            return;
          }

          if (inputText == null) return;

          const words = inputText.split(" ");
          const stateList = [];
          const actionList = [];

          for (let i = 0; i < words.length; i++) {
            if (i !== 0) {
              stateList.push(capitalize(words[i]));
            } else {
              stateList.push(words[i]);
            }
            actionList.push(capitalize(words[i]));
          }

          const transformedState = stateList.join("");
          const transformedAction = "set" + actionList.join("");
          const text = `const [${transformedState} , ${transformedAction}] = useState(null)`;

          const editor = vscode.window.activeTextEditor;

          if (editor) {
            const selection = editor.selection;

            editor.edit((editBuilder) => {
              editBuilder.replace(selection, text);
            });
          }
    });

    context.subscriptions.push(disposable);
}

// This method is called when your extension is deactivated
function deactivate() {}

function capitalize(word) {
    return word.charAt().toUpperCase() + word.slice(1);
}


module.exports = {
    activate,
    deactivate
}

The activate function registers the react-setstate.setState command id, which we defined earlier in the extension.js file.

Next, we need to update the package.json file to reflect this change. We should rename our command to react-setstate.setState and give it a suitable title. For now, we will call it React setState, but you can choose any name you prefer.

"commands": [
    {
      "command": "react-setstate.setState",
      "title": "React setState"
    }
  ]

Don't forget to update the "activationEvents" array as well.

"activationEvents": [
    "onCommand:react-setstate.setState"
  ],

After the extension is activated, the user will be prompted to enter the name of the state they want to create, which will be stored in the inputText variable.

const inputText = await vscode.window.showInputBox({
    placeHolder: "Eg: show modal",
    prompt: "Enter the name of your state.",
  });

If the user didn't type anything in and left the prompt empty, we will close the prompt and return a message indicating that no state was created.

if (inputText === "") {
    vscode.window.showErrorMessage(
      "You need to type in something for this to work😊."
    );
    return;
  }
if (inputText == null) return;

The reason for splitting the text based on space is that a state name could potentially have multiple words, such as "show modal", and we want to be able to capitalize each word individually.

const words = inputText.split(" ");

The capitalize function is a helper function that takes a string and capitalizes the first letter of each word in the string. We will use this function to ensure that the state name entered by the user is properly capitalized.

function capitalize(word) {
    return word.charAt().toUpperCase() + word.slice(1);
}

The conventional way of creating states in React involves defining a variable using the useState hook, which typically looks like this:

const [showModal, setShowModal] = useState(false)

On the left-hand side, we have the state itself, and on the right-hand side, we have the action. That is why we have two arrays: stateList will store the capitalized versions of all the words the user typed, except for the first word.

for (let i = 0; i < words.length; i++) {
    if (i !== 0) {
      stateList.push(capitalize(words[i]));
    } else {
      stateList.push(words[i]);
    }
    actionList.push(capitalize(words[i]));
  }

const stateList = ['show', 'Modal']
const actionList = ['Show', "Modal']

After the code above, the stateList array should contain all the capitalized words from the user input except for the first one. The actionList array should contain the capitalized version of the first word followed by the word "Modal".

  if (i !== 0) {
      stateList.push(capitalize(words[i]));
    }

We can concatenate the elements in our stateList array to form a string. Since stateList already has all the capitalized words we need, we can join them together directly without any further processing.

const transformedState = stateList.join(""); // showModal

Here we are joining the elements of actionList array to form a string with the prefix set.

const transformedAction = "set" + actionList.join("");

Now we should have two separate strings.

const transformedState = "showModal"
const transformedAction = "setShowModal"

All we have to do now it bring them together.

const text = `const [${transformedState} , ${transformedAction}] = useState(null)`;

This is insert transformedState and transformedAction string into the string above.

const text = `const [showModal , setShowModal] = useState(null)`;

Our string should now look like the above.

Now that we have our state, we need a way to paste that text in our editor/VS Code.

const editor = vscode.window.activeTextEditor;

To get the current active text editor, we use vscode.window.activeTextEditor. Then we can use selection.active to get the position of the cursor in the text editor.

  const selection = editor.selection;

Finally, we use the line below to replace the text on that line with our text.

if (editor) {
    const selection = editor.selection;

    editor.edit((editBuilder) => {
      editBuilder.replace(selection, text);
    });
  }

To test if everything is working as expected, you can run the extension by pressing Ctrl + F5.

Publishing our extension

With everything working as expected, it's time to publish our extension and make it available for others to use. To do this, we'll need a personal access token from Azure DevOps and a publisher account.

Once you've set up your organization in Azure DevOps, you can follow these steps to generate your personal access token:

Personal Access Token

Click on the user icon next to the profile image.
Click on Personal access token.
This should take you to a page to generate new token.
Click on New Token to open a modal.
On the modal, provide the necessary info for your token.
Click on Show more scopes and look for Marketplace and check the option for Manage.
Click create to create your token.
Make sure to copy the token as we will need it later.

Publisher

We need to create a publisher to publish our extension under. Follow these steps:

Go to the publisher registration page.
Click on Create Publisher to create a new publisher.
Remember to copy and paste the unique publisher name somewhere safe, as we will need it later for logging in.

With the publisher name copied, we need to update/create the publisher field in the package.json file with our publisher name.

  "publisher": "your-publisher-name",

Installing vsce

npm install -g @vscode/vsce

vsce is a CLI tool for managing VS Code extensions. Use it to login with your publisher name and personal access token.

vsce login <unique publisher name>

vsce publish

If you encounter an error message instructing you to update the README.md file, you can either use the following template or create your own README.md text.

# react-setstate README

react-setstate is an extension that allows react developers to create state quickly.

Once the extension has been published, it will undergo verification on the VS Code Marketplace, which may take several minutes. You can check the status of the verification process here.

Congratulations! Your extension has been successfully created and published on the VS Code [marketplace].
(https://marketplace.visualstudio.com/vscode) for anyone to download and use.

Checkout source code here.
Download the extension here.

Learn the MERN stack - by building an Instagram clone (Part Two)

Sylvester Asare Sarpong — Sun, 13 Mar 2022 11:20:37 +0000

In the last article we set up our backend, now we need a frontend need to connect to our backend.
It is the MERN stack so we will use React.
But before anything let's start our server with node server.js.

Open your terminal and run npm create-react-app <project-name-here> to create a new react project. Replace <project-name-here> with the name of your project.
After the react project is done installing, cd into the project directory, we will need to run npm i react-router-dom axios. We will use axios to make request to the backend and react-router-dom to allow route between different pages in our web app.
In our root project directory let's create .env and add the following

REACT_APP_BE=http://localhost:5000

This adds the value of our backend server which we can access anywhere in our code with process.env.REACT_APP_BE.

Clean up

By default React comes with some boiler plate code in the App.js file, which we will not need so you can delete everything in between the brackets of the return method.

//App.js
import "./App.css";

function App() {
  return (
    <div></div>
  );
}

export default App;

Our App.js should look like this.
Now we have to set up the routes to the pages for logging and registering an account, but we have not any pages to point them to so let's go and create them.
In the src folder, create a new folder called pages.

Login Page

In the pages folder create a new folder and name it Login. In the Login folder, create two files, Login.js and styles.css.

//Login.js
import React, { useState } from "react";
import axios from "axios";
import "./styles.css";
import { useNavigate } from "react-router-dom";
const Login = () => {
  const navigate = useNavigate();

  const [username, setUsername] = useState("");
  const [password, setPassword] = useState("");
  const handleSubmit = (e) => {
    e.preventDefault();
    var data = JSON.stringify({
      username,
      password
    });

    var config = {
      method: "post",
      url: `${process.env.REACT_APP_BE}/users/login`,
      headers: {
        Accept: "application/json",
        "Content-Type": "application/json"
      },
      data: data
    };

    axios(config)
      .then(function (response) {
        localStorage.setItem("my_user_token", response.data.token);
        navigate("/home");
      })
      .catch(function (error) {
        console.log(error);
      });
  };
  return (
    <div className="login-wrapper">
      <form onSubmit={(e) => handleSubmit(e)}>
        <input
          onChange={(e) => setUsername(e.target.value)}
          placeholder="username"
          type="text"
        />
        <br />
        <input
          onChange={(e) => setPassword(e.target.value)}
          placeholder="password"
          type="password"
        />
        <br />
        <button>login</button>
        <a  href="/register" className="create-account">create an account</a>
      </form>
    </div>
  );
};

export default Login;

The above is pretty easy, let's break it down

We create a functional component for the Login page, with the input fields and button to login. There is also a link a register page which we will create later. We use the onChange event to listen for changes in the input fields and update the states.
In the handleSubmit function, we execute the e.preventDefault() to prevent the form from being submitted. Then we store the values of the username and password and add them to the config object which contain other information like the type of request we will like to make, the url we are making the request to and the headers required.
With the config object encapsulating all the data we need, we can make our post request. This the request is successful and we are able to login, we get back the user data along with the generate token which we will store in the brower's localStorage for use later.

/*styles.css*/
.login-wrapper{
    width: 100vw;
    height: 100vh;
    background-color: #222;
    display: flex;
    flex-direction: row;
    align-items: center;
    justify-content: center;
}



input{
    outline: none;
    margin-bottom: 10px;
    width: 300px;
    padding: 10px;
    font-size: 16px;
    font-family: 'Courgette', cursive;
    font-family: 'Raleway', sans-serif;
    border-radius: 5px;
    border: 0;
}

button{
    background: rgb(77, 247, 43);
    border: 0;
    width: 100%;
    padding: 10px;
    border-radius: 5px;
    outline: none;
    margin: auto;
    font-family: 'Courgette', cursive;
    font-family: 'Raleway', sans-serif;
    font-weight: bold;
    cursor: pointer;
    margin-bottom: 10px;
}

.create-account{
    color: white;
    text-decoration: none;
    float: right;
}

.create-account:hover{
text-decoration: underline;
}

Styles for the Login.js.

Sign up page

//SignUp.js
import React, {useState} from "react";
import axios from "axios";
import { useNavigate } from "react-router-dom";
const SignUp = () => {

  const navigate = useNavigate();

  const [username, setUsername] = useState("");
  const [password, setPassword] = useState("");
  const handleSubmit = (e) => {
    e.preventDefault();
    var data = JSON.stringify({
      username,
      password
    });

    var config = {
      method: "post",
      url: `${process.env.REACT_APP_BE}/users/register`,
      headers: {
        Accept: "application/json",
        "Content-Type": "application/json"
      },
      data: data
    };

    axios(config)
      .then(function (response) {
        localStorage.setItem("my_user_token", response.data.token);
        navigate("/home");
      })
      .catch(function (error) {
        console.log(error);
      });
  };
  return (
    <div className="login-wrapper">
      <form onSubmit={(e) => handleSubmit(e)}>
        <input
          onChange={(e) => setUsername(e.target.value)}
          placeholder="username"
          type="text"
        />
        <br />
        <input
          onChange={(e) => setPassword(e.target.value)}
          placeholder="password"
          type="password"
        />
        <br />
        <button>register</button>
        <a href="/" className="create-account">
          already have an account
        </a>
      </form>
    </div>
  );
};

export default SignUp;

In the pages folder, create a SignUp folder and create a SignUp.js file. The logic here is the same as the one in the Login.js file, where we get the username and password and make a post request to the /register route and navigate to the Home page if the credentials are valid.

Defining the Home page and defining the routes for all the pages

Now that we have designed pages for users to login and register, we need to set up a Home page to route users to after a successful request. In the pages folder create a Home folder and create a Home.js and styles.css file.

//Home.js
import React from "react";
import "./styles.css";

const Home = () => {

  return (
    <div>Home</div>
  );
};

export default Home;

The code above creates a default Home.js file. We will come back to the Home file later, now let's go back to our App.js file and define the routes for the individual pages.

import { BrowserRouter, Route, Routes } from "react-router-dom";
import "./App.css";
import Home from "./pages/Home/Home";
import Login from "./pages/Login/Login";
import SignUp from "./pages/SignUp/SignUp";

function App() {
  return (
    <BrowserRouter>
      <Routes>
        <Route exact path="/"  element={<Login/>} />
        <Route exact path="/register" element={<SignUp/>} />
        <Route exact path="/home" element={<Home/>} />
      </Routes>
    </BrowserRouter>
  );
}

export default App;

We import the BrowserRouter, Route and Routes from react-router-dom and also import the individual files themselves. Now we specify the our initial route should be a the Login page, /register for the SignUp and /home for Home.

Back to the Home page

Before we continue with the Home page, we need to know how our Home is going to look like. On the Home page:

User should see their posts and other posts by other users.
Add a new post.
Also add comment on posts.

When the user gets routed to the Home page, they will see all the posts added by others, so we need to make a request to the /posts to get all post in the database.

//Home.js
import React, { useEffect, useState } from "react";
import axios from "axios";
import "./styles.css";

const Home = () => {
  const [posts, setPosts] = useState([]);
  const [userName, setUsername] = useState("");


  useEffect(() => {
    var token = localStorage.getItem("my_user_token");
    var base64Url = token.split(".")[1];
    var base64 = base64Url.replace("-", "+").replace("_", "/");
    setUsername(JSON.parse(atob(base64)).username);
    var config = {
      method: "get",
      url: `${process.env.REACT_APP_BE}/posts`,
      headers: {
        Authorization: `Bearer ${localStorage.getItem("my_user_token")}`
      }
    };

    axios(config)
      .then(function (response) {
        setPosts(response.data);
      })
      .catch(function (error) {
        navigate("/");
        console.log(error);
      });
  }, []);

  return (
    <div>Home</div>
  );
};

export default Home;

In the above code, when the user gets routed to we make a request to the /posts routes to get the all the posts in the database. With posts we got from the database we can map from the posts and pass each one as props to our PostCard component. Remember when we sign the username and id when creating the token, now we use

    var base64 = base64Url.replace("-", "+").replace("_", "/");
    setUsername(JSON.parse(atob(base64)).username);

to decode the token payload and set the username state to the extracted username.

All these will be the Home page, so will need component to manage each of these action want the user to perform. A PostCard component to display user posts, a Comments component view to view comments on posts and also add a new comment. One last component to help us add a new post, AddPost.

PostCard component

We will first start with the PostCard component.
In the src folder, create a components folder and create a new PostCard folder. In the PostCard folder, create two files, one for PostCard.js and the other styles.css.

//PostCard.js
import React from "react";
import profile from "../../assets/images/profile.jpg";


import "./styles.css";
const PostCard = ({ post }) => {


  return (
    <div className="post-card">
      <div className="post-card-header">
        <img src={profile} className="avatar" />
        {post.username}
      </div>
      <img src={post.image} alt={post.caption} className="post-image" />
      <div className="post-card-body">
        <span className="username">{post.username} </span>
        <span className="post-caption">{post.caption}</span>
        {post.comments.length > 0 ? (
          <p className="view-comments">
            View all comments
          </p>
        ) : (
          <p className="view-comments">
            No comments yet
          </p>
        )}
      </div>
    </div>
  );
};
export default PostCard;

Later when pass our post in the PostCard component, we can get the username, caption and image associated with that post. We also import a default profile image to use as the avatar for each user.
Below is the styles for the post card.

/*styles.css*/
.wrapper {
  max-width: 900px;
  margin: auto;
  display: grid;
  grid-template-columns: 550px auto;
  border: 1px solid #f3f3f3;
}

.left-side {
  margin-top: 40px;
}

.right-side {
  margin-top: 40px;
}

.header {
  width: 100%;
  background-color: rgb(0, 255, 187);
  height: 40px;
  position: fixed;
}

.user-profile-wrapper {
  background-color: white;
  padding: 15px;
  font-weight: bold;
  margin-top: 20%;
  display: flex;
  align-items: center;
  justify-content: space-between;
}
.user-profile {
  display: flex;
  align-items: center;
  justify-content: center;
}
.logout {
  cursor: pointer;
  color: rgb(0, 57, 172);
}

.avatar-lg {
  width: 50px;
  height: 50px;
  border-radius: 50%;
  margin-right: 10px;
}

.inner-header {
  max-width: 900px;
  margin: auto;
  display: grid;
  grid-template-columns: 550px;
  text-align: right;
}

@media only screen and (max-width: 768px) {
  .wrapper {
    grid-template-columns: auto;
  }

  .user-profile-wrapper {
    border: 1px solid #f0ebeb;
    padding: 5px;
    flex-grow: 1;
  }
  .right-side {
    position: fixed;
    left: 0;
    bottom: 0;
    width: 100%;
  }

  .avatar-lg {
    width: 30px;
    height: 30px;
  }
  .header {
    display: flex;
    justify-content: flex-end;
  }
  .inner-header {
    padding-right: 10px;
  }
}

Now that we have PostCard ready we can loop through our array of posts returned from the backend and pass them as props into the PostCard.
Before our state gets complicated let create a context file to make a state management easy.
In the components folder lets create a showContext.js file

//showContext.js
import React from "react";
export const ShowContext = React.createContext({});

The context will help manage our state and make them accessible to all children in the context provider.

//Home.js
import axios from "axios";
import React, { useEffect, useState } from "react";
import Comments from "../../components/Comments/Comments";
import PostCard from "../../components/PostCard/PostCard";
import { ShowContext } from "../../components/showContext";
import "./styles.css";
import { useNavigate } from "react-router-dom";
import AddPost from "../../components/AddPost/AddPost";
const Home = () => {
  const navigate = useNavigate();
  const [showComments, toggleComments] = useState(false);
  const [showAddPosts, toggleAddPost] = useState(false);
  const [posts, setPosts] = useState([]);
  const [userName, setUsername] = useState("");
  useEffect(() => {
    var token = localStorage.getItem("my_user_token");
    var base64Url = token.split(".")[1];
    var base64 = base64Url.replace("-", "+").replace("_", "/");
    setUsername(JSON.parse(atob(base64)).username);
    var config = {
      method: "get",
      url: `${process.env.REACT_APP_BE}/posts`,
      headers: {
        Authorization: `Bearer ${localStorage.getItem("my_user_token")}`
      }
    };

    axios(config)
      .then(function (response) {
        setPosts(response.data);
      })
      .catch(function (error) {
        navigate("/");
        console.log(error);
      });
  }, [showAddPosts]);

  const handleLogout = () => {
    localStorage.removeItem("my_user_token");
    navigate("/");
  };
  return (
<ShowContext.Provider
 value={{
        comments: [showComments, toggleComments],
        add: [showAddPosts, toggleAddPost]
      }}
>
        <div className="wrapper">
          <div className="left-side">
            {posts.map((ele, i) => {
              return <PostCard post={ele} key={i} />;
            })}
          </div>
        </div>
    </ShowContext.Provider>
  );
};

export default Home;

Since we going to have a component to make comments and another to add posts, we create the context to pass values from the top down the individual components.
We wrap the return jsx with a context provider and pass in the values of comments and add. Comments

/*styles.css*/
.wrapper {
  max-width: 900px;
  margin: auto;
  display: grid;
  grid-template-columns: 550px auto;
  border: 1px solid #f3f3f3;
}

.left-side {
  margin-top: 40px;
}

Now our Home.js should look like this. We loop through the posts state and we have also some few classes to style the page.

Our home page should look something like this if have posts in your database.

Right now we can only see the posts we made in the previous tutorial, but before we user provide users with a button to add new posts. Let's make sure they can add comments on existing posts.

Commenting on posts

//Comments.js
import React, { useContext, useRef, useEffect, useState } from "react";
import "./styles.css";
import profile from "../../assets/images/profile.jpg";
import { ShowContext } from "../showContext";
import UserComment from "./UserComment";
import axios from "axios";
const Comments = () => {
  const { comments } = useContext(ShowContext);
  const [showComments, toggleComments] = comments
  const [clickState, setClickState] = useState(false);
  const [content, setContent] = useState("");
  const cardRef = useRef();
  console.log(showComments);
  useEffect(() => {
    function handleClickOutside(event) {
      if (cardRef.current && !cardRef.current.contains(event.target)) {
        toggleComments({
          status: false,
          post: null
        });
      }
    }

    document.addEventListener("mousedown", handleClickOutside);
    return () => {
      document.removeEventListener("mousedown", handleClickOutside);
    };
  }, [clickState, toggleComments]);

  const handleSubmit = (e) => {
    e.preventDefault();
    var postId = showComments.post._id;
    var token = localStorage.getItem("my_user_token");
    var base64Url = token.split(".")[1];
    var base64 = base64Url.replace("-", "+").replace("_", "/");
    var userId = JSON.parse(atob(base64)).id;

    var data = JSON.stringify({
      content
    });
    var config = {
      method: "post",
      url: `${process.env.REACT_APP_BE}/posts/add-comment/${postId}/${userId}`,
      headers: {
        Accept: "application/json",
        "Content-Type": "application/json",
        Authorization: `Bearer ${localStorage.getItem("my_user_token")}`
      },
      data: data
    };

    axios(config)
      .then(function (response) {
        console.log(JSON.stringify(response.data));
      })
      .catch(function (error) {
        console.log(error);
      });
  };

  return (
    <div onClick={() => setClickState(!clickState)} className="comments-modal">
      <div ref={cardRef} className="comment-card">
        <div
          className="comment-img"
          style={{
            background: `url(${showComments.post.image})`,
            backgroundRepeat: "no-repeat",
            backgroundPosition: "center",
            backgroundSize: "cover"
          }}
        ></div>
        <div className="comments-main">
          <div className="post-card-header">
            <img src={profile} className="avatar" />
            {showComments.post.username}
          </div>
          {showComments.post.comments.map((ele, i) => {
            return <UserComment key={i} item={ele} />;
          })}
          <form onSubmit={(e) => handleSubmit(e)} className="form">
            <input
              onChange={(e) => setContent(e.target.value)}
              placeholder="say something..."
              className="form-input"
              type="text"
            />
          </form>
        </div>
      </div>
    </div>
  );
};
export default Comments;

Let break the code.
Our comment component is going to be modal with black overlay, that has consist of a grid with the image of the post we are commenting on the left and the other comments on the right.

The root div of the component a function setClickState to close the modal whenever the user clicks outside the comment box(with ref of cardRef) or the in the black overlay.
The div is a grid container of the post image and the comments section with the list all comments. so now need to allow users to able to add new posts.
When we submit our comment to hit the /post/add-comment endpoint passing in the id of the post and the id of the user.

Add new posts

In the header div in on our Home page, we will add a button to add a new button.

//AddPost.js
import React, { useRef, useEffect, useState, useContext } from "react";
import axios from "axios";
import FileBase64 from "react-file-base64";
import "./styles.css";
import { ShowContext } from "../showContext";
const AddPost = () => {
  const cardRef = useRef();

  const { add } = useContext(ShowContext);
  const [showAddPosts, toggleAddPost] = add;
  const [clickState, setClickState] = useState(false);
  const [picture, setPicture] = useState(null);
  const [caption, setCaption] = useState("");
  const [showError, setShowError] = useState(false);
  useEffect(
    () => {
      function handleClickOutside(event) {
        if (cardRef.current && !cardRef.current.contains(event.target)) {
          toggleAddPost(!showAddPosts)
        }
      }
      document.addEventListener("mousedown", handleClickOutside);
      return () => {
        document.removeEventListener("mousedown", handleClickOutside);
      };
    },
    [clickState]
  );
  function getFile(file) {
    var exp = /\d+/;
    if (file.size.match(exp)[0] > 100) {
      setShowError(true);
    } else {
      setShowError(false);
      setPicture(file);
    }
  }

  const handleSubmit = e => {
    e.preventDefault();
    var token = localStorage.getItem("my_user_token");
    var base64Url = token.split(".")[1];
    var base64 = base64Url.replace("-", "+").replace("_", "/");
    var userId = JSON.parse(atob(base64)).id;

    var data = JSON.stringify({
      caption,
      image: picture.base64
    });

    var config = {
      method: "post",
      url: `${process.env.REACT_APP_BE}/posts/add/${userId}`,
      headers: {
        Accept: "application/json",
        "Content-Type": "application/json",
        Authorization: `Bearer ${localStorage.getItem("my_user_token")}`
      },
      data: data
    };

    axios(config)
      .then(function(response) {
            toggleAddPost(!showAddPosts);

      })
      .catch(function(error) {
        console.log(error);
      });
  };
  return (
    <div onClick={() => setClickState(!clickState)} className="comments-modal">
      <div ref={cardRef} className="comment-card">
        <div
          className="comment-img add-post"
          style={{
            backgroundRepeat: "no-repeat",
            backgroundSize: "contain",
            backgroundPosition: "center",
            background: picture ? `url(${picture.base64})` : null
          }}
        >
          {showError && <p className="error">File must be less 100kb</p>}
          {!picture
            ? <FileBase64 onDone={getFile} />
            : <span onClick={() => setPicture(null)} className="remove-button">
                x
              </span>}
        </div>

        <div className="comments-main">
          <form onSubmit={e => handleSubmit(e)} className="form">
            <input
              onChange={e => setCaption(e.target.value)}
              placeholder="say something..."
              className="form-input"
              type="text"
            />
          </form>
        </div>
      </div>
    </div>
  );
};

export default AddPost;

The AddPost component looks like Comments modal with a grid layout for one the image and one for the comments.
The user click on the choose file button to add an image and after they can type in the input field to caption the post.
On submit we hit /posts/add/ endpoint and also check the file size if below 100kb.

Now we can add new post and also make comments on existing posts.

Finishing up

<ShowContext.Provider
      value={{
        comments: [showComments, toggleComments],
        add: [showAddPosts, toggleAddPost]
      }}
    >
      <div>
        {showComments.status ? <Comments /> : null}
        {showAddPosts ? <AddPost /> : null}
        <div className="header">
          <div onClick={() => toggleAddPost(true)} className="inner-header">
            new post
          </div>
        </div>
        <div className="wrapper">
          <div className="left-side">
            {posts.map((ele, i) => {
              return <PostCard post={ele} key={i} />;
            })}
          </div>
          <div className="right-side">
            <div className="user-profile-wrapper">
              <div className="user-profile">
                {userName}
              </div>
              <span onClick={handleLogout} className="logout">
                logout
              </span>
            </div>
          </div>
        </div>
      </div>
    </ShowContext.Provider>

Because the Comment and AddPost components are modal we can display all at once on the page. We only need to appear when a condition is met. So the Comments will show when the showComments.status is true and AddPost will show when the showAddPosts is true.
We also need a logout button.

Update the Home styles.css

.wrapper {
  max-width: 900px;
  margin: auto;
  display: grid;
  grid-template-columns: 550px auto;
  border: 1px solid #f3f3f3;
}

.left-side {
  margin-top: 40px;
}

.right-side {
  margin-top: 40px;
}

.header {
  width: 100%;
  background-color: rgb(0, 255, 187);
  height: 40px;
  position: fixed;
}

.user-profile-wrapper {
  background-color: white;
  padding: 15px;
  font-weight: bold;
  margin-top: 20%;
  display: flex;
  align-items: center;
  justify-content: space-between;
}
.user-profile {
  display: flex;
  align-items: center;
  justify-content: center;
}
.logout {
  cursor: pointer;
  color: rgb(0, 57, 172);
}

.avatar-lg {
  width: 50px;
  height: 50px;
  border-radius: 50%;
  margin-right: 10px;
}

.inner-header {
  max-width: 900px;
  margin: auto;
  display: grid;
  grid-template-columns: 550px;
  text-align: right;
  cursor: pointer;
}

@media only screen and (max-width: 768px) {
  .wrapper {
    grid-template-columns: auto;
  }

  .user-profile-wrapper {
    border: 1px solid #f0ebeb;
    padding: 5px;
    flex-grow: 1;
  }
  .right-side {
    position: fixed;
    left: 0;
    bottom: 0;
    width: 100%;
  }

  .avatar-lg {
    width: 30px;
    height: 30px;
  }
  .header {
    display: flex;
    justify-content: flex-end;
  }
  .inner-header {
    padding-right: 10px;
  }
}

Now our code should be working perfectly. You can expand the currently feature and a like button and other stuff.

Check the out the full code here.
Check the demo here.

Learn the MERN stack - by building an Instagram clone (Part One)

Sylvester Asare Sarpong — Mon, 07 Mar 2022 21:23:50 +0000

MERN stack is made up of four technologies

M for MongoDB: MongoDB is a NoSQL database that stores data as JSON objects.
E for Express: Express is a NodeJS framework that is used for building web and mobile applications.
R for React: React is frontend framework built by Facebook for building single page applications.
N for Node: Node is JavaScript backend runtime environment.

To learn the MERN stack we will be developing an Instagram clone from back to front. So we will start with our node backend. This will be a two part tutorial. This article will focus on the backend.
This tutorial assumes you already have NodeJS installed and also have a basic understanding of JavaScript.

Now let's start.

Open your favorite text editor and create a new project directory and name it whatever you want. I am using VS Code but you can use any editor of your choice.

Set up project and install packages

After creating your project directory open the terminal in your project directory and run: npm init -y to generate an empty project without going through an interactive process.
With the project set up, we need to install the following packages, run npm i express mongoose cors dotenv. Express to set up the server and mongoose to serve as a client for mongoDB. Dotenv is be used to store our environmental values. We also install nodemon, run the npm i -D nodemon. This will install nodemon as devDependency, nodemon restarts our server every time it detects changes in any of the project files. You can choose to ignore installing nodemon.

server.js file

Create a server.js file in the main project directory and add the following code.

const express = require("express");
const cors = require("cors");

const app = express();

const port = process.env.PORT || 5000;
app.use(cors());
app.use(express.json());


app.listen(port, () => {
  console.log(`Server running on port: ${port}`);
});

We import express and set up the express server on port 5000 and we also import the cors middleware and use it an express middleware. We will start our sever by running nodemon server.js if you did not install nodemon, then run node server.js

MongoDB Set up

Now before we proceed to anything, we need set up our database to store user, posts and other stuff. So let's go over to mongoDB , create an account if you don't have one already. Create a new project and given it a name

Click on build a database.

Select the free account

Click on create cluster on next page.

Create the username and password for the database (remember the password, you are going to need it later). Also add the IP address of the your computer, you can add an IP of 0.0.0.0 to allow access from anywhere. After filling fields you click on finish and close to complete the process, it might take a while to complete setting up your cluster.

Connecting MongoDB to our node server

Now that we have our cluster ready, we need to connect our database to the server. On the database deployment page click on connect and click on connect application. Copy the connection string, it should look something like this mongodb+srv://<username>:<password>@cluster0.xzfc0.mongodb.net/<database-name>?retryWrites=true&w=majority
Replace <username>, <password>, <database-name> with the respectively values in your database.

Create .env file

Create an .env file in the project directory.

ATLAS_URI=mongodb+srv://<username>:<password>@cluster0.xzfc0.mongodb.net/<database-name>?retryWrites=true&w=majority

Now we can access the database from anywhere using the process.env.ATLAS_URI

Setting the mongoose client

const express = require("express");
const mongoose = require("mongoose");
const cors = require("cors");
require("dotenv").config();

const app = express();

const port = process.env.PORT || 5000;
app.use(cors());
app.use(express.json());

const uri = process.env.ATLAS_URI;
mongoose.connect(uri, { useNewUrlParser: true });

const connection = mongoose.connection;
connection.once("open", () => {
  console.log("Databse connection established");
});

app.listen(port, () => {
  console.log(`Server running on port: ${port}`);
});

We import the dotenv to allow us to access ATLAS_URI in the .env. Next we connect the mongoose client to to the mongoDB database by passing in the connection string and setting useNewUrlParser: true. Then after, we listen for database connection with once open callback function to signify that a database connection has been established.

Now you are done with the database set up and we can now start writing some code.

Defining the database models.

This is how our application is going to work, first a user creates an account, then they can post an content with an image attached to it, users can also comment on the posts.
Now that we understand how our application works, we can conclude that we need we different document types, one for Users, one for Comments and another for Posts.

Defining the User Model.

//user.model.js
const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const userSchema = new Schema({
  username: {
    type: String,
    required: true,
    trime: true,
    minlength: 3
  },
  password: {
    type: String,
    required: true,
    trime: true,
    minlength: 3
  }
});
const User = mongoose.model("User", userSchema);
module.exports = User;

We start off by creating a models folder in the project directory and then creating a user.model.js file.
We import Schema from mongoose, this will help us define the template Schema for how every user document will look like. The first property in schema is username which he set to required and trim to remove whitespace around the text. We also set the type to String and set a minlength to 3. The same constraint are applied to the password property. After defining the schema we create the User model in the database with mongoose.model("User", userSchema) and then export model for use outside the file.

Defining the Comment model

//comment.model.js
const mongoose = require("mongoose");
const Schema = mongoose.Schema;

const commentSchema = new Schema({
  content: {
    type: String,
    required: true,
    trim: true
  },
  username: {
    type: String
  }
});

const Comment = mongoose.model("Comment", commentSchema);
module.exports = Comment;

Just as we did for the user.model.js file, we will create comment.model.js in the model folder. The comment schema constraints will be similar to those in the user schema.

Defining the Post model.

//post.model.js
const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const postSchema = new Schema({
  caption: {
    type: String
  },
  image: {
    type: String
  },
  comments: [{ type: Schema.Types.ObjectId, ref: "Comment" }],
  username: {
    type: String
  },
  date: {
    type: Date,
    default: Date.now
  }
});

const Post = mongoose.model("Post", postSchema);
module.exports = Post;

We will also create a post.model.js in the models folder. The schema here looks like the previous ones with a few differences so let's address them. The first one, comments, we reference the Comment model and put it in square brackets to signify that anything stored as comments here will be pushed to an array. The date property uses the type Date and set the date when a new instance of the model is created.

Defining the Routes

Now that we have described what each model should look like, we need to set the endpoint for users to be able to make requests to create account, login, add post and also add comments. We will start with defining the user route to register and login.

Defining the user route.

The user route will allow users to create new account and also login, which means we will be dealing with user passwords. User passwords are sensitive and we don't want anyone with access to the database to just login and collect user passwords. So we will use bcryptjs to hash the password and store the returned value in the database along with other user data. We also need to install jsonwebtoken to generate authentication token for login and register sessions. Run the following npm i bcryptjs jsonwebtoken.
bcryptjs uses a secret to decode and encode data. To generate this secret we use the crypto package that comes default with Node. Insert the following anywhere in your server.js.

console.log(require('crypto').randomBytes(64).toString('hex'))
// you can delete this line once the string has been generated
//3f362725c4b4a206be3a7e17b2451d6c274f3b8190a0b7eb642ab53ff3537bb9cc6060913dbc7321dc00fd45158f4c9dffb2c5554ed9b834d0b09fab7a4dd8bc

Copy the generated the text and store it in your .env file.

TOKEN_SECRET=3f362725c4b4a206be3a7e17b2451d6c274f3b8190a0b7eb642ab53ff3537bb9cc6060913dbc7321dc00fd45158f4c9dffb2c5554ed9b834d0b09fab7a4dd8bc

Now we can access the TOKEN_SECRET from anywhere using the process.env.TOKEN_SECRET
Create a router folder and create a users.js file

//users.js
const router = require("express").Router();
const bcrypt = require("bcryptjs");
const jwt = require("jsonwebtoken");
let User = require("../models/user.model");

function generateAccessToken(id, username) {
  return jwt.sign({ id, username }, process.env.TOKEN_SECRET, {
    expiresIn: "3600s"
  });
}


router.route("/register").post((req, res) => {
  const { username, password } = req.body;

  if (!password || !username) {
    return res.status(400).json({ msg: "Please Fill All Fields" });
  }

  const newUser = new User({ username, password });
  User.findOne({ username: username }, (err, user) => {
    if (user) {
      res.send({ message: "User Already Exist" });
    } else {
      bcrypt.genSalt(10, (err, salt) => {
        bcrypt.hash(newUser.password, salt, (err, hash) => {
          if (err) throw err;
          newUser.password = hash;
          newUser.save().then((user) => {
            const token = generateAccessToken(user.id, user.username);
            res.json({
              token,
              user
            });
          });
        });
      });
    }
  });
});

router.route("/login").post((req, res) => {
  const { username, password } = req.body;

  if (!password || !username) {
    return res.status(400).json({ msg: "Please Fill All Fields" });
  }
  User.findOne({ username: username.toLowerCase() }, (err, user) => {
    if (user) {
      bcrypt.compare(password, user.password).then((isMatch) => {
        if (!isMatch)
          return res.status(400).json({ msg: "Invalid Credentials" });

        const token = generateAccessToken(user.id, user.username);

        res.json({
          token,
          user
        });
      });
    }
  });
});

module.exports = router;

Let's break down the code above.

We first import the express router, bcryptjs and jsonwebtoken.
Next we define a function to encode the user id and username into the generate token with a lifetime of 3600s (1hr), later when generate the token we will be able decode the token and get back the username and id.
The first route is a /register, we destructure the request body to get the username and password. We also check the values of the username and password fields and throw an error if empty.
Store the username and password in the User model we created early, then we will check is the provided username already exists in the database if so then we throw an error.
Else if the username does not exist in the database, we use the genSalt method of bcryptjs to generate random bits and add them to our password before hashing it.
After the hash is generated we replace the text password with the hash.
We call the generateAccessToken to create a new token for the user and send back the token with the user info.
The next route is the /login route. It is pretty much the as the /register route, the only different is that instead generating a salt we compare the password provided by the user with the hash password stored in the database and if there is a match we proceed like we did with the /register route.
Lastly, export the user router.

To be able to use the user router, we need to import it in the server.js file.

const usersRouter = require("./routes/users");
app.use("/users", usersRouter);

Defining the auth middleware and the posts route

Now that we have create our users, they need to be able to add posts and also comment on other posts. But will need to only allow authenticated users to be able to perform the previously mentioned functions. So we will need to create an auth middleware to check if the user has a valid token before they can post or make comments.
In the project directory create a middleware folder and add an auth file.

//auth.js
const jwt = require("jsonwebtoken");

module.exports = (req, res, next) => {
  const authHeader = req.headers["authorization"];
  const token = authHeader && authHeader.split(" ")[1];

  if (token === null) return res.sendStatus(401);

  jwt.verify(token, process.env.TOKEN_SECRET, (err, user) => {
    if (err) return res.sendStatus(403);
    req.user = user;
    next();
  });
};

We import the jsonwebtoken and check for an authorization header in the user request and extract the authorization token by splitting the headers, if they is no token an error is thrown. Else we verify the token to check if it has not expired and then execute the next() function to pass control over to the next middleware. We export the function also to allow access from anywhere.
Now back to the post route.
In the routes folder create a post.js file.

//post.js
const router = require("express").Router();
const auth = require("../middleware/auth");
let Comment = require("../models/comment.model");
let Post = require("../models/post.model");
let User = require("../models/user.model");

// get all post
router.get("/", auth, (req, res) => {
  Post.find()
    .sort({ date: -1 })
    .then((posts) => res.json(posts))
    .catch((err) => res.status(400).json("error: " + err));
});
// add a new post
router.route("/add/:id").post(auth, async (req, res) => {
  const { caption, image } = req.body;
  const { id } = req.params;
  const user = await User.findById(id);
  const newPost = new Post({
    caption,
    image,
    username: user.username
  });
  newPost
    .save()
    .then(() => res.json("Post Added"))
    .catch((err) => res.status(400).json(err));
});
//add a comment 
router.route("/add-comment/:id/:userId").post(auth, async (req, res) => {
  const { id, userId } = req.params;
  const { content } = req.body;
  const user = await User.findById(userId);

  const newContent = new Comment({
    content,
    username: user.username
  });
  newContent.save().then(() => res.json("Comment Added"));
  Post.findByIdAndUpdate(
    { _id: id },
    { $push: { comments: newContent } },
    (err, data) => {
      if (err) res.status(400).json("error: " + err);
      else res.status(200).json(data);
    }
  );
});

// get a post
router.route("/:id").get(auth, (req, res) => {
  Post.findById(req.params.id, (err, post) => {
    if (err) res.status(400).json("error: " + err);
    else res.status(200).json(post);
  });
});

// get all comments for a post
router.route("/comments/:id").get(auth, (req, res) => {
  Post.findById(req.params.id, (err, post) => {
    if (err) res.status(400).json("error: " + err);
    else res.status(200).json(post.comments);
  });
});
module.exports = router;

The first part of the code import the express, the auth middleware and the various models we will use later.

The first route is the a get route that returns all the posts in the database sorting it in a descending order date-wise. We pass in the middleware function, to ensure that request is been made by an authenticated user.
The next route is a post route to add a new post. We destructure the caption and image from the request body and also the id of the username from request params. We use an async function to get the username from the User model and store the new post in the Post model.
After saving the model, we then save the model instance in the database.
Next, we define the add a comment, this is also a post request method. We pass in the id of the post the usernames is commenting and userId of the user making the comment. We destructure the req.body to get the content of the user comment and store it the comment model and save it in the database.
After saving the new comment we need to find the specific post the user wants to comment in the database and update by pushing the new comment to its comment array.
The next route is a get method to fetch single post from the database.
And the last route is a get method that returns all comment made under a specific post.
Lastly we export the router.

We use the auth middleware in all the above route to make sure only authenticate can use them.

After exporting the router we will import in our server.js file and define the endpoint to the post router.

const postsRouter = require("./routes/posts");
app.use("/posts", postsRouter);

Defining the comment route

Because the comments are been stored in their own model whenever we make a request in the post router, the comments will be returned as ObjectId, so we will need to define a route to get the actual data from the database.
Create a comment.js file in the routes folder.

const router = require("express").Router();
const auth = require("../middleware/auth");
let Comment = require("../models/comment.model");

router.route("/:id").get(auth, (req, res) => {
  Comment.findById(req.params.id, (err, comment) => {
    if (err) res.status(400).json("error: " + err);
    else res.status(200).json(comment);
  });
});
module.exports = router;

We import the express router, the auth middleware and the Comment model. Then we define a get method fetch a the user comment. And export the router like we did for the other routers.
We import the comment router in the server.js file, now the server.js file should look something like this.

//server.js
const express = require("express");
const mongoose = require("mongoose");
const cors = require("cors");
require("dotenv").config();

const app = express();

const port = process.env.PORT || 5000;
app.use(cors());
app.use(express.json());

const uri = process.env.ATLAS_URI;
mongoose.connect(uri, { useNewUrlParser: true });

const connection = mongoose.connection;
connection.once("open", () => {
  console.log("Databse connection established");
});

const usersRouter = require("./routes/users");
const postsRouter = require("./routes/posts");
const commentRouter = require("./routes/comment");

app.use("/users", usersRouter);
app.use("/posts", postsRouter);
app.use("/comment", commentRouter);

app.listen(port, () => {
  console.log(`Server running on port: ${port}`);
});

Now everything should be working fine and we should be able to login, create an account, add posts and also make comments.

A recap of what we have done so far

We set up our express server and mongoDB database.
Next, We generated a jwt secret.
Then we define the models for the user, comment and post.
After that we defined the routes for the individual models. This concludes everything we need to do on the backend, next up is the frontend. You get access to the full backend code here