From 4573594c85ba19703f62fa8ffad6c38b950d22d4 Mon Sep 17 00:00:00 2001
From: jake <jake.young.dev@gmail.com>
Date: Fri, 26 Sep 2025 16:46:40 -0400
Subject: [PATCH] moving to struct as param, readme updates

---
 README.md | 12 +++++++-----
 lazy.go   | 42 +++++++++++++++++++++++++++++-------------
 2 files changed, 36 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index afcdf41..5ff9f23 100644
--- a/README.md
+++ b/README.md
@@ -9,10 +9,12 @@ This function expects the SQL query, the example response object, and an optiona
 
 <b>Example Object</b> The example object argument <u>must</u> be a struct and requires "db" tags. The db tags are then parsed and used to calculate the psuedo-random rows and values
 
-<b>Primary Key</b> The optional primary key argument is used to hardcode a primary key field in the returned mocks, the primary key field in the example struct <u>must</u> have a test tag with the value "key"
+<b>Primary Key</b> The optional primary key argument is used to hardcode a primary key field in the returned mocks, the primary key field in the example struct <u>must</u> have a lazy tag with the value "key"
+
+<b>Row Count</b> Row count sets the amount of mock rows to generate, if set to 0 then one row will be generated. If primary keys are provided you must provide one per row.
 ```go
 type Mock struct {
-    Field1 string `db:"field1" test:"key"`
+    Field1 string `db:"field1" lazy:"key"`
 }
 ```
 
@@ -22,17 +24,17 @@ func Test() {
     testArg := 123
     query := `SELECT ...`
     type results struct {
-        Field1 string   `db:"field1" test:"key"`
+        Field1 string   `db:"field1" lazy:"key"`
         Field2 int      `db:"field2"`
     }
 
-    rando, err := GenerateRandomResults(query, results{}, testArg)
+    rando, err := GenerateRandomResults(query, results{}, []any{testArg}, 1)
     if err != nil {
         panic(err)
     }
 
     //the rando object will now have psuedo random values in all fields except for the field containing the test tag set to "key" that field will be hardcoded with the testArg to allow for unit tests to ensure the requested ID flows through
-    rows := sqlmock.NewRows(rando.Columns).AddRow(rando.Rows...)
+    rows := sqlmock.NewRows(rando.Columns).AddRows(rando.Rows...)
     mock.ExpectQuery(rando.Query).WithArgs(testArg).WillReturnRows(rows)
 
     ...
diff --git a/lazy.go b/lazy.go
index b4ed27a..9195290 100644
--- a/lazy.go
+++ b/lazy.go
@@ -11,35 +11,51 @@ import (
 	"github.com/jmoiron/sqlx"
 )
 
+const (
+	DB_TAG    = "db"
+	LAZY_TAG  = "lazy"
+	KEY_VALUE = "key"
+)
+
 type MockResults struct {
 	Query   string
 	Columns []string
 	Rows    [][]driver.Value
 }
 
-func GenerateRandomResults(query string, exampleObj any, keyVal []any, rowCount int) (*MockResults, error) {
-	if exampleObj == nil {
-		return nil, errors.New("exampleObj cannot be nil")
+type MockDetails struct {
+	Query    string
+	Example  any
+	Keys     []any
+	RowCount int
+}
+
+func GenerateRandomResults(m MockDetails) (*MockResults, error) {
+	if m.Example == nil {
+		return nil, errors.New("example value cannot be nil")
 	}
-	if rowCount == 0 {
-		rowCount = 1
+	if reflect.ValueOf(m.Example).Kind() != reflect.Struct {
+		return nil, errors.New("example value must be a struct")
 	}
-	if len(keyVal) != 0 {
-		if len(keyVal) != rowCount {
+	if m.RowCount == 0 {
+		m.RowCount = 1
+	}
+	if len(m.Keys) != 0 {
+		if len(m.Keys) != m.RowCount {
 			return nil, errors.New("you must provide a key for each row")
 		}
 	}
 
-	retType := reflect.TypeOf(exampleObj)
+	retType := reflect.TypeOf(m.Example)
 	maxFieldCount := retType.NumField()
 	columns := make([]string, 0, maxFieldCount)
 	rows := make([][]driver.Value, 0)
 
-	for y := 0; y < rowCount; y++ {
+	for y := 0; y < m.RowCount; y++ {
 		rows = append(rows, make([]driver.Value, 0))
 		for x := 0; x < maxFieldCount; x++ {
 			field := retType.Field(x)
-			dbTag := field.Tag.Get("db")
+			dbTag := field.Tag.Get(DB_TAG)
 			if dbTag == "" {
 				continue
 			}
@@ -48,8 +64,8 @@ func GenerateRandomResults(query string, exampleObj any, keyVal []any, rowCount
 				columns = append(columns, dbTag)
 			}
 
-			if field.Tag.Get("test") == "key" {
-				rows[y] = append(rows[y], keyVal[y])
+			if field.Tag.Get(LAZY_TAG) == KEY_VALUE {
+				rows[y] = append(rows[y], m.Keys[y])
 				continue
 			}
 
@@ -63,7 +79,7 @@ func GenerateRandomResults(query string, exampleObj any, keyVal []any, rowCount
 	}
 
 	return &MockResults{
-		Query:   sqlx.Rebind(sqlx.AT, regexp.QuoteMeta(query)),
+		Query:   sqlx.Rebind(sqlx.AT, regexp.QuoteMeta(m.Query)),
 		Columns: columns,
 		Rows:    rows,
 	}, nil