fix create

Author: gmhafiz

README.md

@@ -11,13 +11,18 @@ Examples of using various popular database libraries and ORM in Go.
 The aim is to demonstrate and compare usage for several operations
 
  1. Simple CRUD operation
- 2. 1-1 queries
- 3. 1-to-Many queries
- 4. Many-to-many queries
- 5. Dynamic list filter from query parameter 
- 6. Transaction
+ 2. 1-to-Many queries
+ 3. Many-to-many queries
+ 4. Dynamic list filter from query parameter 
+ 5. Transaction
 
-The schema contains optional fields, for example middle name, and a field that must not be returned, for example, a password.
+# Schema
+
+![Database](db.png)
+
+There are four tables. The `users` table and `addresses` table are linked by the pivot `user_addresses` table. The `addresses` table contains a foreign key to `countries` to demonstrate 1-to-many relationship.
+
+To make things interesting, we make `middle_name` an optional field. We also have a 'protected/hidden' field in which we do not want to return in a JSON response, like a password.
 
 
 # Usage
@@ -30,6 +35,8 @@ Setup postgres database by either running from docker-compose or manually.
 
 This creates both `postgres` database (which this repo uses) and `ent` database which is used by ent ORM.
 
+If you create the database manually, execute the `database/01-schema.sql` script.
+
 Default database credentials are defined in `config/config.go`. These can be overwritten by setting environment variables. For example:
 
     export DB_NAME=test_db

db.png

@@ -1,9 +1,13 @@
 package schema
 
 import (
+	"context"
 	"entgo.io/ent"
 	"entgo.io/ent/schema/edge"
 	"entgo.io/ent/schema/field"
+	"entgo.io/ent/schema/mixin"
+	"fmt"
+	"time"
 )
 
 // User holds the schema definition for the User entity.
@@ -36,3 +40,72 @@ func (User) Edges() []ent.Edge {
 		edge.From("addresses", Address.Type).Ref("users"),
 	}
 }
+
+// AuditMixin implements the ent.Mixin for sharing
+// audit-log capabilities with package schemas.
+type AuditMixin struct {
+	mixin.Schema
+}
+
+// Fields of the AuditMixin.
+func (AuditMixin) Fields() []ent.Field {
+	return []ent.Field{
+		field.Time("created_at").
+			Immutable().
+			Default(time.Now),
+		field.Int("created_by").
+			Optional(),
+		field.Time("updated_at").
+			Default(time.Now).
+			UpdateDefault(time.Now),
+		field.Int("updated_by").
+			Optional(),
+	}
+}
+
+// Hooks of the AuditMixin.
+func (AuditMixin) Hooks() []ent.Hook {
+	return []ent.Hook{
+		AuditHook,
+	}
+}
+
+// A AuditHook is an example for audit-log hook.
+func AuditHook(next ent.Mutator) ent.Mutator {
+	// AuditLogger wraps the methods that are shared between all mutations of
+	// schemas that embed the AuditLog mixin. The variable "exists" is true, if
+	// the field already exists in the mutation (e.g. was set by a different hook).
+	type AuditLogger interface {
+		SetCreatedAt(time.Time)
+		CreatedAt() (value time.Time, exists bool)
+		SetCreatedBy(int)
+		CreatedBy() (id int, exists bool)
+		SetUpdatedAt(time.Time)
+		UpdatedAt() (value time.Time, exists bool)
+		SetUpdatedBy(int)
+		UpdatedBy() (id int, exists bool)
+	}
+	return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+		ml, ok := m.(AuditLogger)
+		if !ok {
+			return nil, fmt.Errorf("unexpected audit-log call from mutation type %T", m)
+		}
+		usr := ctx.Value("user_id").(int)
+		//if err != nil {
+		//	return nil, err
+		//}
+		switch op := m.Op(); {
+		case op.Is(ent.OpCreate):
+			ml.SetCreatedAt(time.Now())
+			if _, exists := ml.CreatedBy(); !exists {
+				ml.SetCreatedBy(usr)
+			}
+		case op.Is(ent.OpUpdateOne | ent.OpUpdate):
+			ml.SetUpdatedAt(time.Now())
+			if _, exists := ml.UpdatedBy(); !exists {
+				ml.SetUpdatedBy(usr)
+			}
+		}
+		return next.Mutate(ctx, m)
+	})
+}

db/ent/ent/schema/user.go

@@ -18,7 +18,7 @@ func NewRepo(db *gorm.DB) *repo {
 	}
 }
 
-func (r *repo) Create(ctx context.Context, u *sqlx.UserRequest, hash string) {
+func (r *repo) Create(ctx context.Context, u *sqlx.UserRequest, hash string) *User {
 	user := &User{
 		FirstName: u.FirstName,
 		MiddleName: sql.NullString{
@@ -31,6 +31,8 @@ func (r *repo) Create(ctx context.Context, u *sqlx.UserRequest, hash string) {
 	}
 
 	r.db.WithContext(ctx).Create(user)
+
+	return user
 }
 
 func (r *repo) List(ctx context.Context) ([]*sqlx.UserResponse, error) {

db/gorm/simple.go

@@ -2,6 +2,9 @@ package sqlx
 
 import (
 	"encoding/json"
+	"errors"
+	"github.com/jackc/pgconn"
+	"github.com/jackc/pgerrcode"
 	"net/http"
 
 	"github.com/alexedwards/argon2id"
@@ -52,6 +55,18 @@ func (h *handler) Create(w http.ResponseWriter, r *http.Request) {
 
 	_, err = h.db.Create(r.Context(), &request, hash)
 	if err != nil {
+		var pgErr *pgconn.PgError
+		if errors.As(err, &pgErr) {
+			switch pgErr.Code {
+			case pgerrcode.UniqueViolation:
+				http.Error(w, `{"message": "`+ErrUniqueKeyViolation.Error()+`"}`, http.StatusBadRequest)
+				return
+			default:
+				http.Error(w, `{"message": "`+ErrDefault.Error()+`"}`, http.StatusBadRequest)
+				return
+			}
+		}
+
 		http.Error(w, `{"message": "`+err.Error()+`"}`, http.StatusBadRequest)
 		return
 	}

db/sqlx/handler.go

@@ -47,7 +47,7 @@ func (r *database) ListM2M(ctx context.Context) ([]*UserResponseWithAddressesSql
 
 	var all []*UserResponseWithAddressesSqlx
 	for users.Next() {
-		var u user
+		var u userDB
 		if err := users.Scan(&u.ID, &u.FirstName, &u.MiddleName, &u.LastName, &u.Email); err != nil {
 			return nil, fmt.Errorf("db scanning error")
 		}

db/sqlx/manyToMany.go

@@ -2,6 +2,7 @@ package sqlx
 
 import (
 	"database/sql"
+
 	"godb/db/ent/ent/gen"
 )
 
@@ -23,39 +24,38 @@ type UserUpdateRequest struct {
 }
 
 type UserResponse struct {
-	ID         uint   `json:"id,omitempty" db:"id"`
-	FirstName  string `json:"first_name" db:"first_name"`
-	MiddleName string `json:"middle_name,omitempty" db:"middle_name"`
-	LastName   string `json:"last_name" db:"last_name"`
-	Email      string `json:"email" db:"email"`
+	ID         uint   `json:"id,omitempty"`
+	FirstName  string `json:"first_name"`
+	MiddleName string `json:"middle_name,omitempty"`
+	LastName   string `json:"last_name"`
+	Email      string `json:"email"`
 }
 
 type UserResponseWithAddress struct {
-	ID         uint              `json:"id,omitempty" db:"id"`
-	FirstName  string            `json:"first_name" db:"first_name"`
-	MiddleName string            `json:"middle_name,omitempty" db:"middle_name"`
-	LastName   string            `json:"last_name" db:"last_name"`
-	Email      string            `json:"email" db:"email"`
+	ID         uint              `json:"id,omitempty"`
+	FirstName  string            `json:"first_name"`
+	MiddleName string            `json:"middle_name,omitempty"`
+	LastName   string            `json:"last_name"`
+	Email      string            `json:"email"`
 	Address    AddressForCountry `json:"address"`
 }
 
 type UserResponseWithAddressesSqlx struct {
-	ID         uint                `json:"id,omitempty" db:"id"`
-	FirstName  string              `json:"first_name" db:"first_name"`
-	MiddleName string              `json:"middle_name,omitempty" db:"middle_name"`
-	LastName   string              `json:"last_name" db:"last_name"`
-	Email      string              `json:"email" db:"email"`
+	ID         uint                `json:"id,omitempty"`
+	FirstName  string              `json:"first_name"`
+	MiddleName string              `json:"middle_name,omitempty"`
+	LastName   string              `json:"last_name"`
+	Email      string              `json:"email"`
 	Address    []AddressForCountry `json:"address"`
 }
 
 type UserResponseWithAddresses struct {
-	ID         uint    `json:"id,omitempty" `
-	FirstName  string  `json:"first_name"`
-	MiddleName *string `json:"middle_name,omitempty"`
-	//MiddleName null.String    `json:"middle_name,omitempty"`
-	LastName string         `json:"last_name"`
-	Email    string         `json:"email"`
-	Address  []*gen.Address `json:"address"`
+	ID         uint           `json:"id,omitempty" `
+	FirstName  string         `json:"first_name"`
+	MiddleName *string        `json:"middle_name,omitempty"`
+	LastName   string         `json:"last_name"`
+	Email      string         `json:"email"`
+	Address    []*gen.Address `json:"address"`
 }
 
 type AddressResponse struct {

db/sqlx/requestResponse.go

@@ -3,16 +3,13 @@ package sqlx
 import (
 	"context"
 	"database/sql"
-	"errors"
 	"fmt"
 
-	"github.com/jackc/pgconn"
-	"github.com/jackc/pgerrcode"
 	"github.com/jmoiron/sqlx"
 )
 
 const (
-	Insert = "INSERT INTO users (first_name, middle_name, last_name, email, password) VALUES ($1, $2, $3, $4, $5)"
+	Insert = "INSERT INTO users (first_name, middle_name, last_name, email, password) VALUES ($1, $2, $3, $4, $5) RETURNING id, first_name, middle_name, last_name, email, password"
 	List   = "SELECT * FROM users;"
 	Get    = "SELECT * FROM users WHERE id = $1;"
 	Update = "UPDATE users set first_name=$1, middle_name=$2, last_name=$3, email=$4 WHERE id=$5;"
@@ -34,39 +31,37 @@ func NewRepo(db *sqlx.DB) *database {
 	}
 }
 
-func (r *database) Create(ctx context.Context, request *UserRequest, hash string) (sql.Result, error) {
-	_, err := r.db.ExecContext(ctx, Insert,
+func (r *database) Create(ctx context.Context, request *UserRequest, hash string) (*userDB, error) {
+	var u userDB
+	err := r.db.QueryRowContext(ctx, Insert,
 		request.FirstName,
 		request.MiddleName,
 		request.LastName,
 		request.Email,
 		hash,
+	).Scan(
+		&u.ID,
+		&u.FirstName,
+		&u.MiddleName,
+		&u.LastName,
+		&u.Email,
+		&u.Password,
 	)
 	if err != nil {
-		var pgErr *pgconn.PgError
-		if errors.As(err, &pgErr) {
-			switch pgErr.Code {
-			case pgerrcode.UniqueViolation:
-				return nil, ErrUniqueKeyViolation
-			default:
-				return nil, ErrDefault
-			}
-		} else {
-			return nil, ErrDefault
-		}
+		return nil, fmt.Errorf("error creating user record: %w", err)
 	}
 
-	return nil, nil
+	return &u, nil
 }
 
 func (r *database) List(ctx context.Context) (users []*UserResponse, err error) {
 	rows, err := r.db.QueryContext(ctx, List)
 	if err != nil {
-		return nil, fmt.Errorf("db error")
+		return nil, fmt.Errorf("error retrieving user records")
 	}
 
 	for rows.Next() {
-		var u user
+		var u userDB
 		err := rows.Scan(&u.ID, &u.FirstName, &u.MiddleName, &u.LastName, &u.Email, &u.Password)
 		if err != nil {
 			return nil, fmt.Errorf("db scanning error")
@@ -82,18 +77,9 @@ func (r *database) List(ctx context.Context) (users []*UserResponse, err error)
 	return users, nil
 }
 
-type user struct {
-	ID         uint           `db:"id"`
-	FirstName  string         `db:"first_name"`
-	MiddleName sql.NullString `db:"middle_name"`
-	LastName   string         `db:"last_name"`
-	Email      string         `db:"email"`
-	Password   string         `db:"password"`
-}
-
 func (r *database) Get(ctx context.Context, userID int64) (*UserResponse, error) {
-	var u user
-	err := r.db.Get(&u, Get, userID)
+	var u userDB
+	err := r.db.GetContext(ctx, &u, Get, userID)
 	if err != nil {
 		return nil, fmt.Errorf("db error")
 	}
@@ -120,3 +106,12 @@ func (r *database) Update(ctx context.Context, userID int64, req *UserUpdateRequ
 func (r *database) Delete(ctx context.Context, userID int64) (sql.Result, error) {
 	return r.db.ExecContext(ctx, Delete, userID)
 }
+
+type userDB struct {
+	ID         uint           `db:"id"`
+	FirstName  string         `db:"first_name"`
+	MiddleName sql.NullString `db:"middle_name"`
+	LastName   string         `db:"last_name"`
+	Email      string         `db:"email"`
+	Password   string         `db:"password"`
+}

db/sqlx/simple.go

@@ -5,7 +5,7 @@ Content-Type: application/json
 {
   "first_name": "Jake",
   "last_name": "Doe",
-  "email": "jake2@example.com",
+  "email": "jake26@example.com",
   "password": "password"
 }
 

example/rest.http

@@ -16,6 +16,7 @@ import (
 	"godb/config"
 	"godb/db/ent"
 	"godb/db/ent/ent/gen"
+	//_ "godb/db/ent/ent/gen/runtime"
 	gormDB "godb/db/gorm"
 	"godb/db/sqlboiler"
 	"godb/db/sqlc"
@@ -71,6 +72,7 @@ func (a *App) Run() {
 func (a *App) SetupRouter() {
 	a.router = chi.NewRouter()
 	a.router.Use(middleware.Json)
+	a.router.Use(middleware.Audit)
 	a.router.NotFound(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusNotFound)
 		_, _ = w.Write([]byte(`{"message": "endpoint not found"}`))

main.go

@@ -1,10 +1,20 @@
 package middleware
 
-import "net/http"
+import (
+	"context"
+	"net/http"
+)
 
 func Json(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "application/json")
 		next.ServeHTTP(w, r)
 	})
 }
+
+func Audit(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx := context.WithValue(r.Context(), "userID", 1)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}