Feat: make FindUnique variadic with at least 1 required unique field

generator/generator.go

@@ -183,7 +183,7 @@ func GenerateClient(sch schema.Schema, pkgName string, parentImportPath string,
 		"client.gotpl",
 		"tx.gotpl",
 		"builders_create.gotpl",
-		"builders_read.gotpl",
+		"builders_query.gotpl",
 		"relations_runtime.gotpl",
 	}
 	for _, file := range files {
@@ -214,7 +214,7 @@ func GenerateClient(sch schema.Schema, pkgName string, parentImportPath string,
 		mFiles := []string{
 			"model_structs.gotpl",
 			"model_create.gotpl",
-			"model_read.gotpl",
+			"model_query.gotpl",
 			"model_relations.gotpl",
 		}
 		for _, file := range mFiles {

generator/templates/builders_read.gotpl → generator/templates/builders_query.gotpl

@@ -1,7 +1,8 @@
 type FindUniqueBuilder[M any, S any, O any] struct {
-	client   *Queries
-	where    UniquePredicate
-	execFunc func(ctx context.Context, where UniquePredicate, s *S, o *O) (*M, error)
+	client     *Queries
+	where      UniquePredicate
+	additional []Predicate
+	execFunc   func(ctx context.Context, where UniquePredicate, additional []Predicate, s *S, o *O) (*M, error)
 }
 
 func (b *FindUniqueBuilder[M, S, O]) Select(s S) *FindUniqueSelectBuilder[M, S, O] {
@@ -13,7 +14,7 @@ func (b *FindUniqueBuilder[M, S, O]) Omit(o O) *FindUniqueOmitBuilder[M, S, O] {
 }
 
 func (b *FindUniqueBuilder[M, S, O]) Exec(ctx context.Context) (*M, error) {
-	return b.execFunc(ctx, b.where, nil, nil)
+	return b.execFunc(ctx, b.where, b.additional, nil, nil)
 }
 
 type FindUniqueSelectBuilder[M any, S any, O any] struct {
@@ -22,7 +23,7 @@ type FindUniqueSelectBuilder[M any, S any, O any] struct {
 }
 
 func (b *FindUniqueSelectBuilder[M, S, O]) Exec(ctx context.Context) (*M, error) {
-	return b.builder.execFunc(ctx, b.builder.where, &b.selects, nil)
+	return b.builder.execFunc(ctx, b.builder.where, b.builder.additional, &b.selects, nil)
 }
 
 type FindUniqueOmitBuilder[M any, S any, O any] struct {
@@ -31,7 +32,7 @@ type FindUniqueOmitBuilder[M any, S any, O any] struct {
 }
 
 func (b *FindUniqueOmitBuilder[M, S, O]) Exec(ctx context.Context) (*M, error) {
-	return b.builder.execFunc(ctx, b.builder.where, nil, &b.omits)
+	return b.builder.execFunc(ctx, b.builder.where, b.builder.additional, nil, &b.omits)
 }
 
 type FindFirstBuilder[M any, S any, O any] struct {

generator/templates/model_read.gotpl → generator/templates/model_query.gotpl

@@ -1,8 +1,9 @@
-func (d *{{ .Model.Name }}Delegate) FindUnique(where UniquePredicate) *FindUniqueBuilder[{{ .Model.Name }}, {{ .Model.Name }}Select, {{ .Model.Name }}Omit] {
+func (d *{{ .Model.Name }}Delegate) FindUnique(where UniquePredicate, additional ...Predicate) *FindUniqueBuilder[{{ .Model.Name }}, {{ .Model.Name }}Select, {{ .Model.Name }}Omit] {
 	return &FindUniqueBuilder[{{ .Model.Name }}, {{ .Model.Name }}Select, {{ .Model.Name }}Omit]{
-		client:   d.client,
-		where:    where,
-		execFunc: d.client.execute{{ .Model.Name }}FindUnique,
+		client:     d.client,
+		where:      where,
+		additional: additional,
+		execFunc:   d.client.execute{{ .Model.Name }}FindUnique,
 	}
 }
 
@@ -22,14 +23,22 @@ func (d *{{ .Model.Name }}Delegate) FindMany(preds ...Predicate) *FindManyBuilde
 	}
 }
 
-func (q *Queries) execute{{ .Model.Name }}FindUnique(ctx context.Context, where UniquePredicate, selects *{{ .Model.Name }}Select, omits *{{ .Model.Name }}Omit) (*{{ .Model.Name }}, error) {
+func (q *Queries) execute{{ .Model.Name }}FindUnique(ctx context.Context, where UniquePredicate, additional []Predicate, selects *{{ .Model.Name }}Select, omits *{{ .Model.Name }}Omit) (*{{ .Model.Name }}, error) {
 	if where == nil {
 		return nil, fmt.Errorf("at least one unique field must be set for FindUnique")
 	}
 	if err := where.Validate(); err != nil {
 		return nil, err
 	}
-	whereClause, vals := CompilePredicates(q.dialect, []Predicate{where})
+	for _, p := range additional {
+		if p != nil {
+			if err := p.Validate(); err != nil {
+				return nil, err
+			}
+		}
+	}
+	allPreds := append([]Predicate{where}, additional...)
+	whereClause, vals := CompilePredicates(q.dialect, allPreds)
 	if whereClause != "" {
 		whereClause = " WHERE " + whereClause
 	}

integration/main.go

@@ -61,6 +61,29 @@ func seed(db *valk.DB, ctx context.Context) *SeedData {
 		))
 	}
 
+	_, err := db.User.FindUnique(
+		user.EmailPhoneUnique("x@y.com", "+1111"),
+	).Select(user.Select{
+		Id:       true,
+		Email:    true,
+		PhoneNum: true,
+		Profile:  &profile.Select{},
+
+		Posts: post.Query().Where(post.And(
+			post.Title.Contains("super-cool-post"),
+			post.Published.EQ(true),
+		)).
+			Select(post.Select{
+				Id:    true,
+				Title: true,
+				Comments: comment.Query().Where(comment.Or(
+					comment.AuthorId.Contains("xyz"),
+					comment.AuthorId.Contains("abc"),
+				)),
+			}),
+	}).
+		Exec(ctx)
+
 	users, err := db.User.CreateManyAndReturn(usersToCreate...).Exec(ctx)
 	if err != nil {
 		log.Fatalf("failed to create users: %v", err)
@@ -86,7 +109,11 @@ func seed(db *valk.DB, ctx context.Context) *SeedData {
 		user.PhoneNum.Set("555-0001"),
 		user.Password.Set("pass123"),
 		user.Role.Set(valk.UserRole.Student),
-	).Exec(ctx)
+	).Select(user.Select{
+		Id:    true,
+		Email: true,
+	}).
+		Exec(ctx)
 	if err != nil {
 		log.Fatalf("failed to create referrer: %v", err)
 	}
@@ -206,100 +233,16 @@ func main() {
 	ctx := context.Background()
 
 	runMigrations(db, ctx)
-
-	fmt.Println("=== Seeding Data ===")
-	data := seed(db, ctx)
-	fmt.Println("Seeding complete.")
-	fmt.Println()
-
-	all, err := db.User.FindMany().Exec(ctx)
-	if err != nil {
-		log.Fatalf("failed to get all users: %v", err)
-	}
-	fmt.Println("=== ALL ===")
-
-	printJSON(all)
-
-	bleh, err := db.User.FindMany(user.And(
-		user.Email.Contains("@example"),
-		user.Or(
-			user.Email.EQ("referred@example.com"),
-			user.PhoneNum.EQ("+1111"),
-		),
-	)).Select(user.Select{
-		Id: true,
-	}).Exec(ctx)
-	printJSON(bleh)
-
-	fmt.Println("=== QUERY 1: Deep Nested Select ===")
-	resUser, err := db.User.FindFirst(
-		user.Email.EQ("referred@example.com"),
-	).Select(user.Select{
-		Email: true,
-		Profile: profile.Query().Select(profile.Select{
-			Bio: true,
-		}),
-		ReferredBy: user.Query().Select(user.Select{
-			Email:    true,
-			PhoneNum: true,
-		}),
-		Posts: post.Query().Select(post.Select{
-			Title: true,
-			Comments: comment.Query().Select(comment.Select{
-				Textify: true,
-				Meta:    true,
-				Author: user.Query().Select(user.Select{
-					Email: true,
-				}),
-			}),
-		}),
-	}).Exec(ctx)
-
-	if err != nil {
-		log.Fatalf("Query 1 failed: %v", err)
-	}
-	printJSON(resUser)
-	fmt.Println()
-
-	fmt.Println("=== QUERY 2: Omit Nested Fields ===")
-	resPost, err := db.Post.FindFirst(
-		post.Title.Like("%Valkyrie%"),
-	).
-		Select(post.Select{
-			Title:     true,
-			Published: true,
-			Comments: comment.Query().Select(comment.Select{
-				Textify: true,
-				Meta:    true,
-			}),
-		}).
-		Exec(ctx)
-
+	res, err := db.User.FindUnique(
+		user.EmailPhoneUnique("x@y.com", "+1111"),
+		user.RoleOptional.EQ(valk.UserRole.Admin),
+	).Exec(ctx)
 	if err != nil {
-		log.Fatalf("Query 2 failed: %v", err)
+		log.Fatalf("failed to find user: %v", err)
 	}
-	printJSON(resPost)
-	fmt.Println()
+	fmt.Println(res)
+	printJSON(res)
 
-	fmt.Println("=== QUERY 3: Filtering with Relations ===")
-	resComments, err := db.Comment.FindMany(
-		comment.Meta.EQ(data.Meta1),
-	).Select(comment.Select{
-		Textify: true,
-		Meta:    true,
-		Post: post.Query().Select(post.Select{
-			Title: true,
-			Author: user.Query().Select(user.Select{
-				Email: true,
-			}),
-		}),
-	}).Exec(ctx)
-
-	if err != nil {
-		log.Fatalf("Query 3 failed: %v", err)
-	}
-	printJSON(resComments)
-	fmt.Println()
 }
 
 func openConn() *valk.DB {

integration/read_test.go

@@ -818,3 +818,57 @@ func TestRelationSubqueries(t *testing.T) {
 		}
 	})
 }
+
+func TestFindUniqueExtended(t *testing.T) {
+	db, cleanup := setupTestDB(t)
+	defer cleanup()
+	ctx := context.Background()
+
+	adminRole := valk.UserRole.Admin
+	studentRole := valk.UserRole.Student
+
+	_, err := db.User.Create(
+		user.Email.Set("ext_admin@example.com"),
+		user.PhoneNum.Set("1111"),
+		user.RoleOptional.Set(adminRole),
+	).Exec(ctx)
+	if err != nil {
+		t.Fatalf("seed admin failed: %v", err)
+	}
+
+	_, err = db.User.Create(
+		user.Email.Set("ext_student@example.com"),
+		user.PhoneNum.Set("2222"),
+		user.RoleOptional.Set(studentRole),
+	).Exec(ctx)
+	if err != nil {
+		t.Fatalf("seed student failed: %v", err)
+	}
+
+	t.Run("Match unique and non-unique", func(t *testing.T) {
+		res, err := db.User.FindUnique(
+			user.Email.EQ("ext_admin@example.com"),
+			user.RoleOptional.EQ(adminRole),
+			user.PhoneNum.EQ("1111"),
+		).Exec(ctx)
+		if err != nil {
+			t.Fatalf("query failed: %v", err)
+		}
+		if res == nil || res.Email != "ext_admin@example.com" {
+			t.Errorf("expected to find admin user, got: %+v", res)
+		}
+	})
+
+	t.Run("Mismatch on non-unique field", func(t *testing.T) {
+		res, err := db.User.FindUnique(
+			user.Email.EQ("ext_admin@example.com"),
+			user.RoleOptional.EQ(studentRole), // Mismatching role
+		).Exec(ctx)
+		if err != nil {
+			t.Fatalf("query failed: %v", err)
+		}
+		if res != nil {
+			t.Errorf("expected nil result on role mismatch, got: %+v", res)
+		}
+	})
+}

integration/valk.json

@@ -9,5 +9,6 @@
   "output": {
     "client": "./valk",
     "migrations": "./valk/migrations"
-  }
+  },
+  "log":["query"]
 }

integration/valk/allFieldsSoFar.go

@@ -1516,11 +1516,12 @@ func (q *Queries) executeAllFieldsSoFarCreateManyAndReturn(ctx context.Context,
 	}
 	return results, nil
 }
-func (d *AllFieldsSoFarDelegate) FindUnique(where UniquePredicate) *FindUniqueBuilder[AllFieldsSoFar, AllFieldsSoFarSelect, AllFieldsSoFarOmit] {
+func (d *AllFieldsSoFarDelegate) FindUnique(where UniquePredicate, additional ...Predicate) *FindUniqueBuilder[AllFieldsSoFar, AllFieldsSoFarSelect, AllFieldsSoFarOmit] {
 	return &FindUniqueBuilder[AllFieldsSoFar, AllFieldsSoFarSelect, AllFieldsSoFarOmit]{
-		client:   d.client,
-		where:    where,
-		execFunc: d.client.executeAllFieldsSoFarFindUnique,
+		client:     d.client,
+		where:      where,
+		additional: additional,
+		execFunc:   d.client.executeAllFieldsSoFarFindUnique,
 	}
 }
 
@@ -1540,14 +1541,22 @@ func (d *AllFieldsSoFarDelegate) FindMany(preds ...Predicate) *FindManyBuilder[A
 	}
 }
 
-func (q *Queries) executeAllFieldsSoFarFindUnique(ctx context.Context, where UniquePredicate, selects *AllFieldsSoFarSelect, omits *AllFieldsSoFarOmit) (*AllFieldsSoFar, error) {
+func (q *Queries) executeAllFieldsSoFarFindUnique(ctx context.Context, where UniquePredicate, additional []Predicate, selects *AllFieldsSoFarSelect, omits *AllFieldsSoFarOmit) (*AllFieldsSoFar, error) {
 	if where == nil {
 		return nil, fmt.Errorf("at least one unique field must be set for FindUnique")
 	}
 	if err := where.Validate(); err != nil {
 		return nil, err
 	}
-	whereClause, vals := CompilePredicates(q.dialect, []Predicate{where})
+	for _, p := range additional {
+		if p != nil {
+			if err := p.Validate(); err != nil {
+				return nil, err
+			}
+		}
+	}
+	allPreds := append([]Predicate{where}, additional...)
+	whereClause, vals := CompilePredicates(q.dialect, allPreds)
 	if whereClause != "" {
 		whereClause = " WHERE " + whereClause
 	}

integration/valk/category.go

@@ -365,11 +365,12 @@ func (q *Queries) executeCategoryCreateManyAndReturn(ctx context.Context, record
 	}
 	return results, nil
 }
-func (d *CategoryDelegate) FindUnique(where UniquePredicate) *FindUniqueBuilder[Category, CategorySelect, CategoryOmit] {
+func (d *CategoryDelegate) FindUnique(where UniquePredicate, additional ...Predicate) *FindUniqueBuilder[Category, CategorySelect, CategoryOmit] {
 	return &FindUniqueBuilder[Category, CategorySelect, CategoryOmit]{
-		client:   d.client,
-		where:    where,
-		execFunc: d.client.executeCategoryFindUnique,
+		client:     d.client,
+		where:      where,
+		additional: additional,
+		execFunc:   d.client.executeCategoryFindUnique,
 	}
 }
 
@@ -389,14 +390,22 @@ func (d *CategoryDelegate) FindMany(preds ...Predicate) *FindManyBuilder[Categor
 	}
 }
 
-func (q *Queries) executeCategoryFindUnique(ctx context.Context, where UniquePredicate, selects *CategorySelect, omits *CategoryOmit) (*Category, error) {
+func (q *Queries) executeCategoryFindUnique(ctx context.Context, where UniquePredicate, additional []Predicate, selects *CategorySelect, omits *CategoryOmit) (*Category, error) {
 	if where == nil {
 		return nil, fmt.Errorf("at least one unique field must be set for FindUnique")
 	}
 	if err := where.Validate(); err != nil {
 		return nil, err
 	}
-	whereClause, vals := CompilePredicates(q.dialect, []Predicate{where})
+	for _, p := range additional {
+		if p != nil {
+			if err := p.Validate(); err != nil {
+				return nil, err
+			}
+		}
+	}
+	allPreds := append([]Predicate{where}, additional...)
+	whereClause, vals := CompilePredicates(q.dialect, allPreds)
 	if whereClause != "" {
 		whereClause = " WHERE " + whereClause
 	}