Learn about developing high-performance backend applications with Go, using tools like Fiber, gqlgen, and apitest. Gain insights into HTTP, REST API, databases, GraphQL, testing, and deployment.

Back End Development with Go Programming Language.png

newv16.tar.gz

Example

Inventory API Local Storage

REST API Test App

Inventory API MySQL

Simple GraphQL

Blog GraphQL Local Storage

Blog GraphQL MongoDB

Simple GraphQL Test

Inventory API MySQL Test

Blog GraphQL MongoDB Test

[DEPLOY] - Inventory API MySQL

[DEPLOY] - Blog GraphQL MongoDB

[DEPLOY] - Simple GraphQL

Blog GraphQL MongoDB- NO AUTH

[SCHEMA ONLY] - Blog GraphQL Local Storage

In modern backend applications, many programming languages can be chosen, including Go—a programming language that provides high performance with concise syntax and can also be used to develop backend applications, including REST API and GraphQL applications. This course will cover many tools that can be used to develop a backend application, including fiber for REST API application, gqlgen for GraphQL application, and apitest for testing purposes.

In this course, you’ll learn about the main concepts of web applications, including HTTP, REST API, databases, and GraphQL. You’ll cover how to develop a backend application and deploy the application as well. 

By the end of the course, you’ll be able to develop a backend application using REST API and GraphQL approach. Also, you’ll be able to test and deploy the backend application that has been developed.

Building a Backend Application with Go

# Implement the resolver

We start by registering the service component in the resolver so the resolver can implement the functionalities with the component. We implement the functionalities inside the  `schema.resolvers.go` file.

## Create a new blog

Inside the `NewBlog()` function, we create an implementation to add new blog data.

```go
func (r *mutationResolver) NewBlog(ctx context.Context, input model.NewBlog) (*model.Blog, error) {
    var blog *model.Blog = r.blogService.CreateBlog(input)
    return blog, nil
}
```

In the code above, the new blog is created with the `CreateBlog()` function from the service component.

## Edit a blog

Inside the `EditBlog()` function, we create an implementation to edit or update the blog data.

```go
func (r *mutationResolver) EditBlog(ctx context.Context, input model.EditBlog) (*model.Blog, error) {
    blog, err := r.blogService.EditBlog(input)
    if err != nil {
        return &model.Blog{}, err
    }

    return blog, nil
}
```

In the code above, the new blog is edited with the `EditBlog()` function from the service component.

## Delete a blog

Inside the `DeleteBlog()` function, we create an implementation to delete blog data.


```go
func (r *mutationResolver) DeleteBlog(ctx context.Context, input model.DeleteBlog) (bool, error) {
    var result bool = r.blogService.DeleteBlog(input)

    return result, nil
}
```

In the code above, the new blog is deleted with the `DeleteBlog()` function from the service component.

## Get all blog

Inside the `Blogs()` function, we create an implementation to get all blogs.


```go
func (r *queryResolver) Blogs(ctx context.Context) ([]*model.Blog, error) {
    var blogs []*model.Blog = r.blogService.GetAllBlogs()

    return blogs, nil
}
```

In the code above, all blog data is retrieved with the `GetAllBlogs()` function from the service component.

## Get blog by ID

Inside the `Blog()` function, we create an implementation to get the blog by ID.

```go
func (r *queryResolver) Blog(ctx context.Context, id string) (*model.Blog, error) {
    blog, err := r.blogService.GetBlogByID(id)

    if err != nil {
        return &model.Blog{}, err
    }

    return blog, nil
}
```

In the code above, the blog data is retrieved with the `GetBlogByID()` function from the service component.

The complete implementation of the resolver component can be seen in the application below:


Learn how to create a resolver component in the GraphQL application.

Resolver Component Creation for GraphQL

Course Introduction

Introduction to Web Application

REST API Development

GraphQL Development

Application Deployment

Assessment of Back End Development with Go

Appendix

Resolver Component Creation for GraphQL

Implement the resolver

Create a new blog