feat: [#708] facades.DB() Support JSON Where Clauses

Author: almas-x

contracts/database/db/db.go

@@ -110,6 +110,16 @@ type Query interface {
 	OrWhereColumn(column1 string, column2 ...string) Query
 	// OrWhereIn adds an "or where column in" clause to the query.
 	OrWhereIn(column string, values []any) Query
+	// OrWhereJsonContains adds an "or where JSON contains" clause to the query.
+	OrWhereJsonContains(column string, value any) Query
+	// OrWhereJsonContainsKey add a clause that determines if a JSON path exists to the query.
+	OrWhereJsonContainsKey(column string) Query
+	// OrWhereJsonDoesntContain add an "or where JSON not contains" clause to the query.
+	OrWhereJsonDoesntContain(column string, value any) Query
+	// OrWhereJsonDoesntContainKey add a clause that determines if a JSON path does not exist to the query.
+	OrWhereJsonDoesntContainKey(column string) Query
+	// OrWhereJsonLength add an "or where JSON length" clause to the query.
+	OrWhereJsonLength(column string, length int) Query
 	// OrWhereLike adds an "or where column like" clause to the query.
 	OrWhereLike(column string, value string) Query
 	// OrWhereNot adds an "or where not" clause to the query.
@@ -161,6 +171,16 @@ type Query interface {
 	WhereExists(func() Query) Query
 	// WhereIn adds a "where column in" clause to the query.
 	WhereIn(column string, values []any) Query
+	// WhereJsonContains add a "where JSON contains" clause to the query.
+	WhereJsonContains(column string, value any) Query
+	// WhereJsonContainsKey add a clause that determines if a JSON path exists to the query.
+	WhereJsonContainsKey(column string) Query
+	// WhereJsonDoesntContain add a "where JSON not contains" clause to the query.
+	WhereJsonDoesntContain(column string, value any) Query
+	// WhereJsonDoesntContainKey add a clause that determines if a JSON path does not exist to the query.
+	WhereJsonDoesntContainKey(column string) Query
+	// WhereJsonLength add a "where JSON length" clause to the query.
+	WhereJsonLength(column string, length int) Query
 	// WhereLike adds a "where like" clause to the query.
 	WhereLike(column string, value string) Query
 	// WhereNot adds a basic "where not" clause to the query.

contracts/database/driver/conditions.go

@@ -1,5 +1,15 @@
 package driver
 
+// WhereType type of where condition
+type WhereType int
+
+const (
+	WhereTypeBase WhereType = iota
+	WhereTypeJsonContains
+	WhereTypeJsonContainsKey
+	WhereTypeJsonLength
+)
+
 type Conditions struct {
 	CrossJoin     []Join
 	Distinct      *bool
@@ -30,7 +40,9 @@ type Join struct {
 }
 
 type Where struct {
+	Type  WhereType
 	Query any
 	Args  []any
 	Or    bool
+	IsNot bool
 }

database/db/builder.go

@@ -3,8 +3,18 @@ package db
 import (
 	"github.com/jmoiron/sqlx"
 	"gorm.io/gorm"
+
+	"github.com/goravel/framework/support/str"
 )
 
+var NameMapper = func(s string) string {
+	if s == "ID" {
+		return "id"
+	}
+
+	return str.Of(s).Snake().String()
+}
+
 type Builder struct {
 	*sqlx.DB
 	gormDB *gorm.DB
@@ -17,6 +27,7 @@ func NewBuilder(gormDB *gorm.DB, driver string) (*Builder, error) {
 	}
 
 	dbx := sqlx.NewDb(db, driver)
+	dbx.MapperFunc(NameMapper)
 
 	return &Builder{
 		DB:     dbx,
@@ -40,6 +51,7 @@ func NewTxBuilder(gormDB *gorm.DB, driver string) (*TxBuilder, error) {
 	}
 
 	dbx := sqlx.NewDb(db, driver)
+	dbx.MapperFunc(NameMapper)
 	tx, err := dbx.Beginx()
 	if err != nil {
 		return nil, err

database/db/query.go

@@ -537,14 +537,11 @@ func (r *Query) OrderByRaw(raw string) db.Query {
 }
 
 func (r *Query) OrWhere(query any, args ...any) db.Query {
-	q := r.clone()
-	q.conditions.Where = append(q.conditions.Where, contractsdriver.Where{
+	return r.addWhere(contractsdriver.Where{
 		Query: query,
 		Args:  args,
 		Or:    true,
 	})
-
-	return q
 }
 
 func (r *Query) OrWhereBetween(column string, x, y any) db.Query {
@@ -568,6 +565,51 @@ func (r *Query) OrWhereIn(column string, values []any) db.Query {
 	return r.OrWhere(column, values)
 }
 
+func (r *Query) OrWhereJsonContains(column string, value any) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonContains,
+		Query: column,
+		Args:  []any{value},
+		Or:    true,
+	})
+}
+
+func (r *Query) OrWhereJsonContainsKey(column string) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonContainsKey,
+		Query: column,
+		Or:    true,
+	})
+}
+
+func (r *Query) OrWhereJsonDoesntContain(column string, value any) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonContains,
+		Query: column,
+		Args:  []any{value},
+		IsNot: true,
+		Or:    true,
+	})
+}
+
+func (r *Query) OrWhereJsonDoesntContainKey(column string) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonContainsKey,
+		Query: column,
+		IsNot: true,
+		Or:    true,
+	})
+}
+
+func (r *Query) OrWhereJsonLength(column string, length int) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonLength,
+		Query: column,
+		Args:  []any{length},
+		Or:    true,
+	})
+}
+
 func (r *Query) OrWhereLike(column string, value string) db.Query {
 	return r.OrWhere(sq.Like{column: value})
 }
@@ -769,13 +811,10 @@ func (r *Query) When(condition bool, callback func(query db.Query) db.Query, fal
 }
 
 func (r *Query) Where(query any, args ...any) db.Query {
-	q := r.clone()
-	q.conditions.Where = append(q.conditions.Where, contractsdriver.Where{
+	return r.addWhere(contractsdriver.Where{
 		Query: query,
 		Args:  args,
 	})
-
-	return q
 }
 
 func (r *Query) WhereBetween(column string, x, y any) db.Query {
@@ -812,6 +851,46 @@ func (r *Query) WhereIn(column string, values []any) db.Query {
 	return r.Where(column, values)
 }
 
+func (r *Query) WhereJsonContains(column string, value any) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonContains,
+		Query: column,
+		Args:  []any{value},
+	})
+}
+
+func (r *Query) WhereJsonContainsKey(column string) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonContainsKey,
+		Query: column,
+	})
+}
+
+func (r *Query) WhereJsonDoesntContain(column string, value any) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonContains,
+		Query: column,
+		Args:  []any{value},
+		IsNot: true,
+	})
+}
+
+func (r *Query) WhereJsonDoesntContainKey(column string) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonContainsKey,
+		Query: column,
+		IsNot: true,
+	})
+}
+
+func (r *Query) WhereJsonLength(column string, length int) db.Query {
+	return r.addWhere(contractsdriver.Where{
+		Type:  contractsdriver.WhereTypeJsonLength,
+		Query: column,
+		Args:  []any{length},
+	})
+}
+
 func (r *Query) WhereLike(column string, value string) db.Query {
 	return r.Where(sq.Like{column: value})
 }
@@ -865,6 +944,13 @@ func (r *Query) WhereRaw(raw string, args []any) db.Query {
 	return r.Where(sq.Expr(raw, args...))
 }
 
+func (r *Query) addWhere(where contractsdriver.Where) db.Query {
+	q := r.clone()
+	q.conditions.Where = append(q.conditions.Where, where)
+
+	return q
+}
+
 func (r *Query) buildDelete() (sql string, args []any, err error) {
 	if r.err != nil {
 		return "", nil, r.err
@@ -1043,13 +1129,39 @@ func (r *Query) buildUpdate(data map[string]any) (sql string, args []any, err er
 func (r *Query) buildWhere(where contractsdriver.Where) (any, []any, error) {
 	switch query := where.Query.(type) {
 	case string:
-		if !str.Of(query).Trim().Contains(" ", "?") {
+		switch where.Type {
+		case contractsdriver.WhereTypeJsonContains:
+			var err error
+			query, where.Args, err = r.grammar.CompileJsonContains(query, where.Args[0], where.IsNot)
+			if err != nil {
+				return nil, nil, errors.OrmJsonContainsInvalidBinding.Args(err)
+			}
+		case contractsdriver.WhereTypeJsonContainsKey:
+			query = str.Of(r.grammar.CompileJsonContainsKey(query, where.IsNot)).Replace("?", "??").String()
+		case contractsdriver.WhereTypeJsonLength:
+			segments := strings.SplitN(query, " ", 2)
+			segments[0] = r.grammar.CompileJsonLength(segments[0])
+			query = strings.Join(segments, " ")
+		default:
+			if str.Of(query).Trim().Contains("->") {
+				segments := strings.Split(query, " ")
+				for i := range segments {
+					if strings.Contains(segments[i], "->") {
+						segments[i] = r.grammar.CompileJsonSelector(segments[i])
+					}
+				}
+				query = strings.Join(segments, " ")
+				where.Args = r.grammar.CompileJsonValues(where.Args...)
+			}
+		}
+		if !str.Of(query).Trim().Contains("?") {
 			if len(where.Args) > 1 {
 				return sq.Eq{query: where.Args}, nil, nil
 			} else if len(where.Args) == 1 {
 				return sq.Eq{query: where.Args[0]}, nil, nil
 			}
 		}
+
 		return query, where.Args, nil
 	case map[string]any:
 		return sq.Eq(query), nil, nil

database/db/utils.go

@@ -123,14 +123,18 @@ func convertToMap(data any) (map[string]any, error) {
 
 		// Get field name from db tag or use field name
 		tag := field.Tag.Get("db")
-		if tag == "" || tag == "-" {
+		if tag == "-" {
 			continue
 		}
 		var fieldName string
-		if comma := strings.Index(tag, ","); comma != -1 {
-			fieldName = tag[:comma]
+		if tag != "" {
+			if comma := strings.Index(tag, ","); comma != -1 {
+				fieldName = tag[:comma]
+			} else {
+				fieldName = tag
+			}
 		} else {
-			fieldName = tag
+			fieldName = NameMapper(field.Name)
 		}
 
 		fieldValue := val.Field(i)

database/db/utils_test.go

@@ -15,9 +15,9 @@ type Body struct {
 	Weight   string  `db:"weight"`
 	Head     *string `db:"head"`
 	Height   int     `db:"-"`
-	Age      uint
-	DateTime carbon.DateTime `db:"date_time"`
-	leg      int             `db:"leg"`
+	Age      uint    `db:"-"`
+	DateTime carbon.DateTime
+	leg      int `db:"leg"`
 }
 
 type User struct {
@@ -65,8 +65,8 @@ func TestConvertToSliceMap(t *testing.T) {
 					TestTimestamps:  TestTimestamps{CreatedAt: dateTime, UpdatedAt: dateTime}},
 			},
 			want: []map[string]any{
-				{"id": 1, "weight": "100kg", "head": &head, "date_time": *dateTime, "created_at": dateTime, "updated_at": dateTime, "deleted_at": deletedAt},
-				{"id": 2, "length": 1, "weight": "90kg", "head": &head, "date_time": *dateTime, "created_at": dateTime, "updated_at": dateTime, "deleted_at": deletedAt},
+				{"id": 1, "email": "john@example.com", "weight": "100kg", "head": &head, "date_time": *dateTime, "created_at": dateTime, "updated_at": dateTime, "deleted_at": deletedAt},
+				{"id": 2, "email": "jane@example.com", "length": 1, "weight": "90kg", "head": &head, "date_time": *dateTime, "created_at": dateTime, "updated_at": dateTime, "deleted_at": deletedAt},
 			},
 		},
 		{
@@ -80,8 +80,8 @@ func TestConvertToSliceMap(t *testing.T) {
 					TestTimestamps:  TestTimestamps{CreatedAt: dateTime, UpdatedAt: dateTime}},
 			},
 			want: []map[string]any{
-				{"id": 1, "weight": "100kg", "head": &head, "date_time": *dateTime, "created_at": dateTime, "updated_at": dateTime, "deleted_at": deletedAt},
-				{"id": 2, "length": 1, "weight": "90kg", "head": &head, "date_time": *dateTime, "created_at": dateTime, "updated_at": dateTime, "deleted_at": deletedAt},
+				{"id": 1, "email": "john@example.com", "weight": "100kg", "head": &head, "date_time": *dateTime, "created_at": dateTime, "updated_at": dateTime, "deleted_at": deletedAt},
+				{"id": 2, "email": "jane@example.com", "length": 1, "weight": "90kg", "head": &head, "date_time": *dateTime, "created_at": dateTime, "updated_at": dateTime, "deleted_at": deletedAt},
 			},
 		},
 		{
@@ -126,9 +126,11 @@ func TestConvertToSliceMap(t *testing.T) {
 		},
 	}
 
-	for _, test := range tests {
-		sliceMap, err := convertToSliceMap(test.data)
-		assert.NoError(t, err)
-		assert.Equal(t, test.want, sliceMap)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sliceMap, err := convertToSliceMap(tt.data)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want, sliceMap)
+		})
 	}
 }