Develop

.cursor/commands/commit.md

@@ -0,0 +1,41 @@
+# AI Git Automator: Atomic Commits (Optimized)
+
+**Goal:** Auto-split independent changes into **well-structured Conventional Commits** with mandatory emojis.
+
+## 1. Analysis & Grouping (Mandatory)
+
+* **Ops:** Run `git status` and `git diff`.
+* **Logic:** Cluster files by **logical concern** (type, scope, or intent).
+* **Constraint:** **MUST SPLIT** commits if changes have different types (e.g., `feat` vs `fix`), different scopes, or can be reverted independently. **Do NOT proceed** without full understanding.
+
+## 2. Execution Loop
+
+*Repeat until worktree clean:*
+
+1. **Stage:** `git add <paths>` (Select **ONE** coherent concern only).
+2. **Commit:** Execute the following command immediately (Verify atomicity internally):
+```bash
+git commit -m "<emoji> <type>(<scope>): <summary>
+
+Why:
+- [Briefly explain the underlying reason/problem]
+What:
+- [Summary of technical changes]
+Files:
+- [Key files/dirs, omit trivial]"
+
+```
+## 3. Final Output (Once Finished)
+
+After all commits are done:
+
+Print a summary table or list: [Hash] | [Emoji] [Title] | [Files Changed].
+
+## 4. Standards & Rules
+
+* **Title:** ≤ 72 chars, imperative mood, focus on **WHY**.
+* **Emoji Map:** 🎸feat, 🐛fix, ✏️docs, 💄style, 💡refactor, ⚡️perf, 💍test, 🎡ci, 🤖chore.
+* **Format:** `<emoji> <type>(<scope>): <summary>` (e.g., `🎸 feat(auth): add google oauth`).
+* **Breaking Change:** Add `!` after type (e.g., `feat!(api): ...`).
+* **Order:** `chore/ci` > `refactor` > `feat` > `fix` > `test` > `docs`.
+* **Safety:** No empty commits; **No config changes**; **No `git push`**.

.cursor/worktrees.json

@@ -0,0 +1,5 @@
+{
+  "setup-worktree": [
+    "npm install"
+  ]
+}

.gitignore

@@ -29,3 +29,5 @@ go.work.sum
 .vscode
 
 .history
+
+.cursor

exposed.go

@@ -29,7 +29,7 @@ var (
 	ToOR = queryset.ToOR
 )
 
-// 泛型包装：在本包重新导出 EachOR
+// EachOR re-exports the generic EachOR function from queryset package
 func EachOR[T Cond | AND | OR](conditions T) T {
 	return queryset.EachOR(conditions)
 }

handler.go

@@ -19,18 +19,22 @@ const (
 )
 
 const (
-	SelectColumsValidateError   = "select columns validate error: %s"
-	SelectColumnsTypeError      = "select type should be string or string slice"
-	OrderByColumnsValidateError = "orderBy columns validate error: [%s] not exist"
-	OrderByColumnsTypeError     = "orderBy type should be string or string slice"
-	GroupByColumnsValidateError = "groupBy columns validate error: %s"
-	GroupByColumnsTypeError     = "groupBy type should be string or string slice"
-	CreateDataTypeError         = "create data type is wrong, should not be [%s]"
-	DataEmptyError              = "data is empty"
-	UpdateColumnNotExistError   = "update column [%s] not exist"
-	ColumnNotExistError         = "column [%s] not exist"
-	MustBeCalledError           = "[%s] must be called after [%s]"
-	UnsupportedControllerError  = "[%s] not supported for %s"
+	ModelTypeNotStructError      = "model must be a pointer to struct"
+	ModelTypeNotSliceError       = "model must be a pointer to slice"
+	SelectColumsValidateError    = "select columns validate error: %s"
+	SelectColumnsTypeError       = "select type should be string or string slice"
+	SelectQualifiedAsteriskError = "qualified wildcard select is not supported: %s"
+	SelectAliasNotSupportedError = "select alias is not supported for %s, please use %s"
+	OrderByColumnsValidateError  = "orderBy columns validate error: [%s] not exist"
+	OrderByColumnsTypeError      = "orderBy type should be string or string slice"
+	GroupByColumnsValidateError  = "groupBy columns validate error: %s"
+	GroupByColumnsTypeError      = "groupBy type should be string or string slice"
+	CreateDataTypeError          = "create data type is wrong, should not be [%s]"
+	DataEmptyError               = "data is empty"
+	UpdateColumnNotExistError    = "update column [%s] not exist"
+	ColumnNotExistError          = "column [%s] not exist"
+	MustBeCalledError            = "[%s] must be called after [%s]"
+	UnsupportedControllerError   = "[%s] not supported for %s"
 )
 
 type controllerCall struct {
@@ -172,10 +176,7 @@ func (m *Impl) setError(format string, a ...any) {
 }
 
 func (m *Impl) haveError() error {
-	if err := m.qs.Error(); err != nil {
-		return err
-	}
-	return nil
+	return m.qs.Error()
 }
 
 // preCheck checks if any unsupported methods have been called for the given operation.
@@ -275,7 +276,7 @@ func (m *Impl) Exclude(exclude ...any) Controller {
 func (m *Impl) Where(cond string, args ...any) Controller {
 	m.setCalled(ctlWhere)
 
-	m.qs.WhereToSQL(cond, args)
+	m.qs.WhereToSQL(cond, args...)
 
 	return m
 }
@@ -292,6 +293,10 @@ func (m *Impl) Select(selects any) Controller {
 		if sel == "" {
 			return m
 		}
+		if hasQualifiedWildcardSelect(sel) {
+			m.setError(SelectQualifiedAsteriskError, sel)
+			return m
+		}
 		m.qs.StrSelectToSQL(sel)
 	case []string:
 		if len(sel) == 0 {
@@ -347,7 +352,7 @@ func (m *Impl) OrderBy(orderBy any) Controller {
 		if len(orderByVal) == 0 {
 			return m
 		}
-		unknownColumns := []string{}
+		var unknownColumns []string
 		for _, by := range orderByVal {
 			if by == "" {
 				continue
@@ -413,7 +418,7 @@ func (m *Impl) GroupBy(groupBy any) Controller {
 // Having adds a HAVING clause to the query.
 func (m *Impl) Having(having string, args ...any) Controller {
 	m.setCalled(ctlHaving)
-	m.qs.HavingToSQL(having, args)
+	m.qs.HavingToSQL(having, args...)
 	return m
 }
 
@@ -477,7 +482,7 @@ func (m *Impl) Create(data any) (idOrNum int64, err error) {
 		return m.bulkCreate(d)
 	default:
 		v := reflect.ValueOf(data)
-		if v.Kind() == reflect.Ptr {
+		if v.Kind() == reflect.Pointer {
 			v = v.Elem()
 		}
 		if v.Kind() == reflect.Struct {
@@ -506,6 +511,10 @@ func (m *Impl) Remove() (num int64, err error) {
 }
 
 func (m *Impl) update(data map[string]any) (num int64, err error) {
+	if len(data) == 0 {
+		return 0, errors.New("update " + DataEmptyError)
+	}
+
 	var (
 		args       []any
 		updateRows []string
@@ -553,7 +562,7 @@ func (m *Impl) Count() (num int64, err error) {
 }
 
 func (m *Impl) findOne() (result map[string]any, err error) {
-	query, args := m.buildQuery(m.fieldRows)
+	query, args := m.buildQuery(m.qs.GetSelectSQL())
 	query += " LIMIT 1"
 
 	res := deepCopyModelPtrStructure(m.modelPtr)
@@ -562,20 +571,29 @@ func (m *Impl) findOne() (result map[string]any, err error) {
 
 	switch {
 	case err == nil:
-		return modelStruct2Map(res, m.operator.GetDBTag()), nil
+		result = modelStruct2Map(res, m.operator.GetDBTag())
 	case errors.Is(err, ErrNotFound):
 		return map[string]any{}, nil
 	default:
 		return map[string]any{}, err
 	}
+
+	if m.hasCalled(ctlSelect) {
+		result = filterBySelectColumns(result, m.qs.GetSelectSQL())
+	}
+
+	return result, nil
 }
 
 // FindOne retrieves a single record matching the current query set into a map.
 // It returns the data as a map, or an error if the operation fails.
 func (m *Impl) FindOne() (result map[string]any, err error) {
-	if err = m.preCheck("FindOne", ctlSelect, ctlHaving); err != nil {
+	if err = m.preCheck("FindOne", ctlHaving); err != nil {
 		return result, err
 	}
+	if m.hasCalled(ctlSelect) && hasSelectAlias(m.qs.GetSelectSQL()) {
+		return result, fmt.Errorf(SelectAliasNotSupportedError, "FindOne", "FindOneModel")
+	}
 
 	return m.findOne()
 }
@@ -588,8 +606,8 @@ func (m *Impl) FindOneModel(modelPtr any) (err error) {
 	}
 
 	rv := reflect.ValueOf(modelPtr)
-	if rv.Kind() != reflect.Ptr || rv.Elem().Kind() != reflect.Struct {
-		return fmt.Errorf("model must be a pointer to struct")
+	if rv.Kind() != reflect.Pointer || rv.Elem().Kind() != reflect.Struct {
+		return fmt.Errorf(ModelTypeNotStructError)
 	}
 
 	query, args := m.buildQuery(m.qs.GetSelectSQL())
@@ -601,25 +619,33 @@ func (m *Impl) FindOneModel(modelPtr any) (err error) {
 // FindAll retrieves all records matching the current query set into a slice of maps.
 // It returns the data as a slice of maps, or an error if the operation fails.
 func (m *Impl) FindAll() (result []map[string]any, err error) {
-	if err = m.preCheck("FindAll", ctlSelect, ctlHaving); err != nil {
+	if err = m.preCheck("FindAll", ctlHaving); err != nil {
 		return result, err
 	}
+	if m.hasCalled(ctlSelect) && hasSelectAlias(m.qs.GetSelectSQL()) {
+		return result, fmt.Errorf(SelectAliasNotSupportedError, "FindAll", "FindAllModel")
+	}
 
-	query, args := m.buildQuery(m.fieldRows)
+	query, args := m.buildQuery(m.qs.GetSelectSQL())
 	query += m.qs.GetLimitSQL()
 
 	res := deepCopyModelPtrStructure(m.modelSlicePtr)
 
 	err = m.operator.FindAll(m.ctx(), res, query, args...)
 
-	switch {
-	case err == nil:
-		return modelStructSlice2MapSlice(res, m.operator.GetDBTag()), nil
-	case errors.Is(err, ErrNotFound):
-		return []map[string]any{}, nil
-	default:
+	if err != nil {
 		return []map[string]any{}, err
 	}
+
+	result = modelStructSlice2MapSlice(res, m.operator.GetDBTag())
+
+	if m.hasCalled(ctlSelect) {
+		for i, row := range result {
+			result[i] = filterBySelectColumns(row, m.qs.GetSelectSQL())
+		}
+	}
+
+	return result, nil
 }
 
 // FindAllModel retrieves all records matching the current query set into a slice of models.
@@ -630,36 +656,26 @@ func (m *Impl) FindAllModel(modelSlicePtr any) (err error) {
 	}
 
 	rv := reflect.ValueOf(modelSlicePtr)
-	if rv.Kind() != reflect.Ptr || rv.Elem().Kind() != reflect.Slice {
-		return fmt.Errorf("model must be a pointer to slice")
+	if rv.Kind() != reflect.Pointer || rv.Elem().Kind() != reflect.Slice {
+		return fmt.Errorf(ModelTypeNotSliceError)
 	}
 
 	query, args := m.buildQuery(m.qs.GetSelectSQL())
 	query += m.qs.GetLimitSQL()
 
 	err = m.operator.FindAll(m.ctx(), modelSlicePtr, query, args...)
-
-	switch {
-	case err == nil:
-		return nil
-	case reflect.ValueOf(modelSlicePtr).Elem().Len() == 0:
-		return ErrNotFound
-	default:
-		return err
-	}
+	return err
 }
 
 // Delete marks the records as deleted by setting the 'is_deleted' field to true.
 // It returns the number of records marked as deleted.
 // Note: This method is not a true delete operation; it only marks records as deleted.
 func (m *Impl) Delete() (num int64, err error) {
-	if err = m.preCheck("Delete", ctlGroupBy, ctlSelect, ctlOrderBy); err != nil {
+	if err = m.preCheck("Delete", ctlSelect, ctlGroupBy, ctlHaving); err != nil {
 		return 0, err
 	}
 
-	data := map[string]any{"is_deleted": true}
-
-	return m.Update(data)
+	return m.update(map[string]any{"is_deleted": true})
 }
 
 func (m *Impl) exist() (exist bool, err error) {
@@ -680,7 +696,7 @@ func (m *Impl) Exist() (exist bool, err error) {
 // List retrieves the total count and all data matching the current query set.
 // It returns the total count, data as a slice of maps, and any error encountered.
 func (m *Impl) List() (total int64, data []map[string]any, err error) {
-	if err = m.preCheck("List", ctlSelect, ctlHaving); err != nil {
+	if err = m.preCheck("List", ctlHaving); err != nil {
 		return 0, data, err
 	}
 
@@ -719,14 +735,16 @@ func (m *Impl) CreateOrUpdate(data map[string]any) (created bool, numOrID int64,
 		return false, 0, err
 	}
 
-	if exist, err := m.exist(); err != nil {
+	exist, err := m.exist()
+	if err != nil {
 		return false, 0, err
-	} else if exist {
-		if num, err := m.update(data); err != nil {
+	}
+	if exist {
+		num, err := m.update(data)
+		if err != nil {
 			return false, 0, err
-		} else {
-			return false, num, nil
 		}
+		return false, num, nil
 	}
 
 	m.reset()