DEV Community: wahid

How to Use Arrays as Parameters in Golang?

wahid — Tue, 28 May 2024 12:08:50 +0000

Declaring Arrays in Golang
Passing Arrays as Function Parameters
Using Slices as Function Parameters
Practical Example: Paginating Data
Conclusion

In Golang, arrays are a fundamental data structure that can be passed as parameters to functions. This article will explain how to use arrays as parameters in Go, including examples of passing arrays with fixed sizes and using slices for more flexibility.

1. Declaring Arrays in Golang

Before passing arrays as parameters, let's review how to declare arrays in Go.

package main

import "fmt"

func main() {
    // Declare an array with a fixed size of 5
    var numbers [5]int
    fmt.Println(numbers) // Output: [0 0 0 0 0]

    // Declare an array with initial values
    primes := [5]int{2, 3, 5, 7, 11}
    fmt.Println(primes) // Output: [2 3 5 7 11]
}

Semilar Contents

Example basic CRUD Operations Using Golang, Gin Gonic, and GORM

2. Passing Arrays as Function Parameters

To pass an array as a parameter to a function, you need to declare the function parameter as an array with a fixed length. Here’s an example:

package main

import "fmt"

// Function that accepts an array with a fixed length of 5
func printArray(arr [5]int) {
    for i, value := range arr {
        fmt.Printf("Element %d: %d\n", i, value)
    }
}

func main() {
    primes := [5]int{2, 3, 5, 7, 11}
    printArray(primes)
}

In the above example, the printArray function accepts a parameter of type array with a length of 5 elements.

3. Using Slices as Function Parameters

In Go, it’s more common to use slices than arrays when passing a collection of data to a function. Slices are more flexible because they do not have a fixed length like arrays.

package main

import "fmt"

// Function that accepts a slice
func printSlice(slice []int) {
    for i, value := range slice {
        fmt.Printf("Element %d: %d\n", i, value)
    }
}

func main() {
    primes := []int{2, 3, 5, 7, 11}
    printSlice(primes)
}

In the example above, the printSlice function accepts a parameter of type slice. You can change the length of a slice without needing to redeclare it like an array.

4. Practical Example: Paginating Data

Let’s apply this concept in a practical example. Suppose you want to create a function to paginate data from a database using GORM in Go. Here is a simple implementation:

package main

import (
    "github.com/gin-gonic/gin"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "net/http"
    "reflect"
    "strconv"
)

type Product struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func main() {
    r := gin.Default()

    db, _ := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    db.AutoMigrate(&Product{})

    r.GET("/products", func(ctx *gin.Context) {
        var responseDto []Product

        page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
        perPage, _ := strconv.Atoi(ctx.DefaultQuery("per_page", "10"))

        ResponseWithPaginate(db, &Product{}, &responseDto, ctx, page, perPage)
    })

    r.Run()
}

func ResponseWithPaginate(c *gorm.DB, data interface{}, responseDto interface{}, ctx *gin.Context, page int, perPage int) {
    var totalItems int64

    err := c.Model(data).Count(&totalItems).Error
    if err != nil {
        ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    result := c.Limit(perPage).Offset((page - 1) * perPage).Find(responseDto)
    if result.Error != nil {
        ctx.JSON(http.StatusNotFound, gin.H{"error": result.Error.Error()})
        return
    }

    meta := NewMeta(ctx, totalItems, int64(reflect.ValueOf(responseDto).Elem().Len()))

    SuccessResponse(ctx, responseDto, meta)
}

func NewMeta(ctx *gin.Context, totalItems, itemCount int64) map[string]interface{} {
    return map[string]interface{}{
        "total_items": totalItems,
        "item_count":  itemCount,
    }
}

func SuccessResponse(ctx *gin.Context, data interface{}, meta map[string]interface{}) {
    ctx.JSON(http.StatusOK, gin.H{
        "data": data,
        "meta": meta,
    })
}

In the example above, the ResponseWithPaginate function accepts a slice as a parameter for responseDto. This slice is used to store the results of the query from the database.

Conclusion

Using arrays or slices as parameters in functions in Golang is straightforward and intuitive. Slices are often preferred due to their flexibility in size. By understanding these basics, you can easily manage and manipulate collections of data in your Go programs.

Basic CRUD Operations Using Golang, Gin Gonic, and GORM

wahid — Fri, 24 May 2024 12:56:40 +0000

Building web applications in Golang is both fun and efficient. Using powerful frameworks like Gin Gonic for the web layer and GORM for ORM (Object-Relational Mapping) makes it easier to create robust and maintainable applications. In this tutorial, we'll demonstrate how to implement basic CRUD operations in a book management system.

Project Structure

We will organize our project using the following structure to maintain clean and manageable code:

belajar-go/
│
├── cmd/
│     └── main.go
├── configs/
│     └── dbConfig.go
├── internal/
│     ├── delivery/
│     │     ├── handlers/
│     │     │     └── bookHandler/
│     │     │          └── bookHandler.go
│     │     ├── data/
│     │     │     ├── request/
│     │     │     │     └── bookReq/
│     │     │     │          └── bookRequest.go
│     │     │     └── response/
│     │     │          ├── bookRes/
│     │     │          │     └── bookResponse.go
│     │     │          └── response.go
│     │     └── router/
│     │           ├── bookRouter/
│     │           │          └── bookRouter.go
│     │           └── router.go
│     ├── domain/
│     │     ├── models/
│     │     │     └── books.go
│     │     ├── repositories/
│     │     │     ├── bookRepo/
│     │     │     │      └── bookRepo.go
│     │     └── services/
│     │           ├── bookService/
│     │           │      └── bookService.go
│     └── infrastructure/
│           └── database/
│                  ├── database.go
│                  └── migrations.go
├── pkg/
│     ├── utils/
│     │     └── base.go
│     └── helpers/
│           └── errorPanic.go
├── .env.example
├── .gitignore
├── go.mod
└── go.sum

Setting Up the Project

Initialize the project:

   go mod init github.com/your-username/belajar-go
   go get -u github.com/gin-gonic/gin
   go get -u gorm.io/gorm
   go get -u gorm.io/driver/postgres

Database Configuration (configs/dbConfig.go):

   package configs

   import (
       "gorm.io/driver/postgres"
       "gorm.io/gorm"
   )

   func ConnectDB() (*gorm.DB, error) {
       dsn := "host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai"
       db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
       if err != nil {
           return nil, err
       }
       return db, nil
   }

Models (internal/domain/models/books.go):

   package models

   import (
       "time"
   )

   type Book struct {
       ID        uint      `gorm:"primaryKey"`
       UUID      string    `gorm:"type:uuid;default:uuid_generate_v4()"`
       Title     string    `gorm:"size:255"`
       Author    string    `gorm:"size:255"`
       Year      int
       CreatedAt time.Time
       UpdatedAt time.Time
   }

Repositories (internal/domain/repositories/bookRepo.go):

   package repositories

   import (
       "github.com/your-username/belajar-go/internal/domain/models"
       "gorm.io/gorm"
   )

   type BookRepository struct {
       Db *gorm.DB
   }

   func NewBookRepository(Db *gorm.DB) *BookRepository {
       return &BookRepository{Db: Db}
   }

   // Implement CRUD operations

Services (internal/domain/services/bookService.go):

   package services

   import (
       "github.com/your-username/belajar-go/internal/domain/models"
       "github.com/your-username/belajar-go/internal/domain/repositories"
   )

   type BookService struct {
       repo *repositories.BookRepository
   }

   func NewBookService(repo *repositories.BookRepository) *BookService {
       return &BookService{repo: repo}
   }

   // Implement service methods

Handlers (internal/delivery/handlers/bookHandler.go):

   package handlers

   import (
       "net/http"

       "github.com/gin-gonic/gin"
       "github.com/your-username/belajar-go/internal/domain/models"
       "github.com/your-username/belajar-go/internal/domain/services"
   )

   type BookHandler struct {
       bookService *services.BookService
   }

   func NewBookHandler(bookService *services.BookService) *BookHandler {
       return &BookHandler{bookService: bookService}
   }

   // Implement handler methods

Router (internal/delivery/router/bookRouter.go):

   package router

   import (
       "github.com/gin-gonic/gin"
       "github.com/your-username/belajar-go/internal/delivery/handlers"
       "github.com/your-username/belajar-go/internal/domain/repositories"
       "github.com/your-username/belajar-go/internal/domain/services"
       "gorm.io/gorm"
   )

   func BookRouter(group *gin.RouterGroup, db *gorm.DB) {
       // Setup routing
   }

Main (cmd/main.go):

   package main

   import (
       "github.com/gin-gonic/gin"
       "github.com/your-username/belajar-go/configs"
       "github.com/your-username/belajar-go/internal/delivery/router"
   )

   func main() {
       // Setup server
   }

Conclusion

By following this guide, you've learned how to create a basic CRUD application using Golang, Gin Gonic, and GORM. This structure helps in maintaining and scaling your application effectively. Happy coding!

For full code klick here

Implementation of Authorization Middleware with NestJS

wahid — Sat, 25 Nov 2023 03:49:42 +0000

Middleware is an integral part of NestJS that allows you to manipulate requests before reaching the controller handler. One commonly used type of middleware is authorization middleware. In this article, we will discuss the implementation of authorization middleware using NestJS with the provided code.

Authorization Middleware Code

// src/middleware/authorization.middleware.ts

import { HttpException, HttpStatus, Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';
import axios, { AxiosError } from 'axios';
import { errorResponse } from '../utils/helper';

@Injectable()
export class AuthorizationMiddleware implements NestMiddleware {
    async use(req: Request, res: Response, next: NextFunction) {
        const authorizationHeader = req.header('Authorization');

        if (!authorizationHeader || !authorizationHeader.startsWith('Bearer ')) {
            throw new HttpException("Unauthenticated.", HttpStatus.UNAUTHORIZED);
        }

        const token = authorizationHeader.split('Bearer ')[1];

        try {
            const isValid = await isTokenValid(token);

            if (isValid) {
                next();
            } else {
                throw new HttpException("Unauthenticated.", HttpStatus.UNAUTHORIZED);
            }
        } catch (error) {
            return errorResponse(error.message, error.status);
        }
    }
}

async function isTokenValid(token: string): Promise<boolean> {
    const domain = process.env.SERVICE_DOMAIN;
    const config = {
        headers: {
            "Content-type": "application/json",
            "Authorization": `Bearer ${token}`,
        },
    };

    try {
        const response = await axios.get(`${domain}/api/user/authenticated`, config);
        if (response.status >= 200 && response.status < 300) {
            return true;
        } else {
            return false;
        }
    } catch (error) {
        if (axios.isAxiosError(error)) {
            const axiosError: AxiosError = error;
            throw new HttpException(axiosError.response?.data || "Authentication failed", axiosError.response?.status || HttpStatus.UNAUTHORIZED);
        } else {
            throw new HttpException("Internal Server Error", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

Steps to Use Authorization Middleware in NestJS

Step 1: Import Middleware

Import the created middleware into the appropriate NestJS module.

// src/app.module.ts

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { AuthorizationMiddleware } from './middleware/authorization.middleware';

@Module({
  // ... other module configurations
})
export class AppModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(AuthorizationMiddleware)
      .forRoutes('/*'); // Set the routes that will use the middleware
  }
}

Step 2: Specify Routes Requiring Authorization

In the example above, authorization middleware will be applied to all routes ('/*'). You can customize it according to your project needs.

Step 3: Run the NestJS Application

After adding authorization middleware, run your NestJS application.

npm run start

Now, each incoming request will pass through the authorization middleware before reaching the controller handler. This middleware will check the authorization header and make decisions based on the token's validity.

With the above steps, you have successfully implemented authorization middleware in NestJS using the provided code. Hopefully, this article helps you enhance the security of your NestJS application.

Conclusion

In conclusion, implementing authorization middleware in NestJS is a crucial step to enhance the security of your application. The provided code demonstrates a middleware that checks the validity of a bearer token before allowing access to protected routes. By following the outlined steps, you can seamlessly integrate this middleware into your NestJS project, ensuring that only authenticated users have access to sensitive endpoints. This approach contributes to a more robust and secure NestJS application architecture.

Adding API Key Middleware in NestJS

wahid — Tue, 07 Nov 2023 12:25:09 +0000

API Key Middleware is a secure way to protect your API by requiring users to include a valid API key in every request. In this guide, we'll walk through the steps to add API Key middleware to your NestJS application.

Step 1: Install NestJS

Before you begin, make sure you have Node.js and NestJS installed on your computer. If not, you can install NestJS with the following command:

npm install -g @nestjs/cli
nest new my-api
cd my-api

Step 2: Configure Environment

Set up environment variables to store your API key. You can use nestjs/config to manage configuration. Create a .env file in your project directory and add the API key:

API_KEY=your-api-key

Next, ensure you have set up the ConfigModule correctly in your AppModule:

import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";

@Module({
  imports: [ConfigModule.forRoot()],
})
export class AppModule {}

Step 3: Create Middleware

Create an API Key middleware named ApiKeyMiddleware. Create a file named api-key.middleware.ts in the appropriate directory in your project and add the following code:
more...

My Awesome Extensions Vscode

wahid — Tue, 26 Sep 2023 11:14:42 +0000

Boosting Developer Productivity with Essential VS Code Extensions

Visual Studio Code (VS Code) is one of the most popular source code editors used by developers worldwide. One of its primary strengths is its customizability through extensions, which allow you to add features and functions as per your needs. In this article, we'll discuss some highly useful extensions to enhance your productivity while using VS Code.

Live Server
The Live Server extension enables you to quickly develop and test websites locally. Once activated, simply click "Go Live," and a local development server will run. This extension automatically refreshes your web page when you save code changes, which is extremely useful during front-end development.
Indent Rainbow
Indent Rainbow is an extension that helps you better understand the structure and hierarchy of your code. It colorizes your code's indentation with different colors for each level of indentation. This is particularly helpful when dealing with deep and nested code.
GitLens
GitLens is a powerful extension for Git management within VS Code. With GitLens, you can see who made changes to the code, when those changes were made, and even access the code's commit history directly from the editor. It simplifies collaboration with development teams and provides a better understanding of project evolution.
Thunder Client
Thunder Client is an extension that allows you to send HTTP requests and test APIs directly from VS Code. With an intuitive interface, you can easily create HTTP GET, POST, PUT, and DELETE requests and observe the received responses. This extension is invaluable for backend development and API testing.
Prettier
Prettier is an extension that helps you maintain consistent code formatting. By integrating Prettier into VS Code, you can easily automate code formatting according to the conventions you specify. This aids in keeping your code clean and easily readable.
Git Graph
Git Graph is an extension that helps you visualize the Git history of your project in an interactive graph format. You can visually explore branches, merges, and commits, which helps you understand your project's structure and relationships between different code segments.

By using these extensions, you can enhance your productivity and code quality while using Visual Studio Code. Each extension has its unique features that can assist you in various aspects of software development. Additionally, these extensions can be easily installed through the VS Code extension marketplace, allowing you to tailor your setup to your specific needs. Try out these extensions to maximize your development experience with VS Code.

DEV Community: wahid

How to Use Arrays as Parameters in Golang?

Table of Contents

1. Declaring Arrays in Golang

Semilar Contents

2. Passing Arrays as Function Parameters

3. Using Slices as Function Parameters

4. Practical Example: Paginating Data

Conclusion

Basic CRUD Operations Using Golang, Gin Gonic, and GORM

Project Structure

Setting Up the Project

Conclusion

Implementation of Authorization Middleware with NestJS

Authorization Middleware Code

Steps to Use Authorization Middleware in NestJS

Step 1: Import Middleware

Step 2: Specify Routes Requiring Authorization

Step 3: Run the NestJS Application

Conclusion

Adding API Key Middleware in NestJS

Step 1: Install NestJS

Step 2: Configure Environment

Step 3: Create Middleware

My Awesome Extensions Vscode