fixed file creation path

Author: coolwednesday

store/README.md

@@ -16,22 +16,25 @@ go install gofr.dev/cli/gofr@latest
 
 1. **Initialize a store configuration:**
    ```bash
-   gofr store init
+   gofr store init -name=user
    ```
-   This creates a `store.yaml` file with example configuration.
+   This creates the following in `stores/user/`:
+   - `store.yaml` — configuration template
+   - `interface.go` — initial interface stub
+   - `user.go` — initial implementation stub
 
-2. **Edit `store.yaml`** with your models and queries (see Configuration Reference below).
+2. **Edit `stores/user/store.yaml`** with your models and queries (see Configuration Reference below).
 
 3. **Generate the store code:**
    ```bash
-   gofr store generate
+   gofr store generate -config=stores/user/store.yaml
    ```
 
 4. **Use in your application:**
    ```go
    import "your-project/stores/user"
-   
-   userStore := user.NewUser()
+
+   userStore := user.NewUserStore()
    result, err := userStore.GetUserByID(ctx, 123)
    ```
 
@@ -40,11 +43,16 @@ go install gofr.dev/cli/gofr@latest
 ### Commands
 
 ```bash
-# Initialize a new store.yaml configuration file
-gofr store init
+# Initialize a new store directory and store.yaml configuration file
+# The -name flag is required
+gofr store init -name=<store-name>
 
-# Generate store code from store.yaml
+# Generate store code from a store.yaml
+# Default config path: stores/store.yaml
 gofr store generate
+
+# Generate store code from a specific config file
+gofr store generate -config=stores/user/store.yaml
 ```
 
 ### Project Structure
@@ -53,11 +61,11 @@ After generation, your project will have:
 
 ```
 stores/
-├── all.go              # Store registry (auto-generated)
-├── user/
-│   ├── interface.go    # UserStore interface
-│   ├── store.go         # UserStore implementation
-│   └── user.go          # User model (if generated)
+├── all.go              # Store registry factory (auto-generated)
+└── user/
+    ├── interface.go    # UserStore interface
+    ├── userStore.go    # userStore implementation boilerplate
+    └── user.go         # User model (if generated)
 ```
 
 ### Using Generated Stores
@@ -66,19 +74,24 @@ stores/
 ```go
 import "your-project/stores/user"
 
-userStore := user.NewUser()
+userStore := user.NewUserStore()
 result, err := userStore.GetUserByID(ctx, id)
 ```
 
 **Option 2: Using the registry**
 ```go
-import "your-project/stores"
+import (
+    "your-project/stores"
+    "your-project/stores/user"
+)
 
-allStores := stores.All()
-userStore := stores.GetStore("user").(user.User)
+// GetStore returns a factory-created instance; cast to the correct interface
+userStore := stores.GetStore("user").(user.UserStore)
 result, err := userStore.GetUserByID(ctx, id)
 ```
 
+> **💡 Note:** `stores.All()` returns a `map[string]func() any` — a map of **factory functions**, not active instances. Use `stores.GetStore(name)` for convenient access.
+
 ### Integration Example
 
 ```go
@@ -91,7 +104,7 @@ import (
 
 func main() {
     app := gofr.New()
-    userStore := user.NewUser()
+    userStore := user.NewUserStore()
 
     app.GET("/users/{id}", func(ctx *gofr.Context) (interface{}, error) {
         id, _ := strconv.ParseInt(ctx.PathParam("id"), 10, 64)
@@ -113,7 +126,7 @@ stores:
   - name: "user"
     package: "user"
     output_dir: "stores/user"
-    interface: "User"
+    interface: "UserStore"
     implementation: "userStore"
     queries:
       - name: "GetUserByID"
@@ -146,10 +159,12 @@ models:
 | `name` | Store identifier (used in registry) | Yes |
 | `package` | Go package name | Yes |
 | `output_dir` | Directory for generated files | Yes |
-| `interface` | Interface name (e.g., "User") | Yes |
-| `implementation` | Implementation struct name | Yes |
+| `interface` | Interface name — **recommended: `<Name>Store`** (e.g., `UserStore`) | Yes |
+| `implementation` | Implementation struct name (e.g., `userStore`) | Yes |
 | `queries` | Array of database queries | Yes |
 
+> **⚠️ Naming Convention:** The registry (`stores/all.go`) automatically appends `"Store"` when building constructor calls. To avoid compilation errors, always name your interface as `<Name>Store` (e.g., `UserStore`) and the generated constructor will be `New<Name>Store()`.
+
 ### Models
 
 **Generate a new model:**
@@ -185,10 +200,10 @@ models:
 - `delete` - DELETE queries
 
 **Return Types:**
-- `single` - Returns a single model instance
-- `multiple` - Returns a slice of models
-- `count` - Returns `int64` count
-- `custom` - Returns `interface{}`
+- `single` - Returns `(*Model, error)`
+- `multiple` - Returns `([]Model, error)`
+- `count` - Returns `(int64, error)`
+- `custom` - Returns `(any, error)`
 
 **Example Query:**
 ```yaml
@@ -206,21 +221,23 @@ queries:
 
 ### Multiple Stores
 
+You can define multiple stores in a single YAML file. Each store gets its own directory and the registry (`stores/all.go`) tracks all of them.
+
 ```yaml
 version: "1.0"
 
 stores:
   - name: "user"
     package: "user"
     output_dir: "stores/user"
-    interface: "User"
+    interface: "UserStore"
     implementation: "userStore"
     queries: [...]
 
   - name: "product"
     package: "product"
     output_dir: "stores/product"
-    interface: "Product"
+    interface: "ProductStore"
     implementation: "productStore"
     queries: [...]
 
@@ -231,6 +248,12 @@ models:
     fields: [...]
 ```
 
+**Accessing multiple stores from the registry:**
+```go
+userStore    := stores.GetStore("user").(user.UserStore)
+productStore := stores.GetStore("product").(product.ProductStore)
+```
+
 ## Generated Code Examples
 
 ### Interface
@@ -240,8 +263,8 @@ package user
 
 import "gofr.dev/pkg/gofr"
 
-type User interface {
-    GetUserByID(ctx *gofr.Context, id int64) (User, error)
+type UserStore interface {
+    GetUserByID(ctx *gofr.Context, id int64) (*User, error)
     GetAllUsers(ctx *gofr.Context) ([]User, error)
 }
 ```
@@ -253,16 +276,18 @@ package user
 
 type userStore struct{}
 
-func NewUser() User {
+func NewUserStore() UserStore {
     return &userStore{}
 }
 
-func (s *userStore) GetUserByID(ctx *gofr.Context, id int64) (User, error) {
+func (s *userStore) GetUserByID(ctx *gofr.Context, id int64) (*User, error) {
     // TODO: Implement query using ctx.SQL()
-    return User{}, nil
+    return &User{}, nil
 }
 ```
 
+> **💡 Note:** The generator creates method **signatures and boilerplate only**. You must implement the actual SQL execution in the `// TODO` sections using `ctx.SQL()` methods.
+
 ### Model
 ```go
 // Code generated by gofr.dev/cli/gofr. DO NOT EDIT.
@@ -277,4 +302,13 @@ type User struct {
 func (User) TableName() string {
     return "user"
 }
-```
+```
+
+## Best Practices
+
+1. **Never Edit Generated Files**: Files marked `DO NOT EDIT` (`interface.go`, `all.go`) are overwritten on every generation. Keep custom SQL logic in your implementation file (e.g., `userStore.go`).
+2. **Use `<Name>Store` Interface Names**: This ensures the registry and constructor align correctly.
+3. **Commit your YAML**: Treat `store.yaml` as source of truth. Re-run `gofr store generate` after every change.
+4. **Reference Existing Models**: If you already have model structs, use the `path` + `package` fields to avoid duplication.
+
+For a complete working example, see [`store/example.yaml`](./example.yaml).

store/generator.go

@@ -141,7 +141,7 @@ func InitStore(ctx *gofr.Context) (any, error) {
 		return nil, fmt.Errorf("failed to create store directory: %w", err)
 	}
 
-	if err := generateStoreConfig(ctx, storeName, storeDir); err != nil {
+	if err := generateStoreConfig(ctx, storeName, "stores"); err != nil {
 		return nil, fmt.Errorf("failed to generate store config: %w", err)
 	}
 
@@ -196,10 +196,15 @@ func GenerateStore(ctx *gofr.Context) (any, error) {
 
 	newStores := make([]Entry, 0, len(cfg.Stores))
 	for i := range cfg.Stores {
+		interfaceName := cfg.Stores[i].Interface
+		if interfaceName == "" {
+			interfaceName = cases.Title(language.English).String(cfg.Stores[i].Name) + "Store"
+		}
+
 		newStores = append(newStores, Entry{
 			Name:          cfg.Stores[i].Name,
-			PackageName:   strings.ToLower(cfg.Stores[i].Name),
-			InterfaceName: cases.Title(language.English).String(cfg.Stores[i].Name) + "Store",
+			PackageName:   cfg.Stores[i].Package,
+			InterfaceName: interfaceName,
 		})
 	}
 
@@ -652,9 +657,15 @@ func generateModelFile(ctx *gofr.Context, modelFile string, store *Info, model *
 	return nil
 }
 
-// generateStoreConfig creates the initial store.yaml configuration file.
-func generateStoreConfig(ctx *gofr.Context, storeName, storeDir string) error {
-	configFile := filepath.Join(storeDir, "store.yaml")
+// generateStoreConfig creates the initial store.yaml configuration file or appends to an existing one.
+func generateStoreConfig(ctx *gofr.Context, storeName, storesDir string) error {
+	configFile := filepath.Join(storesDir, "store.yaml")
+	storeDir := fmt.Sprintf("stores/%s", strings.ToLower(storeName))
+
+	// If file exists, append to it
+	if _, err := os.Stat(configFile); err == nil {
+		return appendToStoreConfig(ctx, configFile, storeName, storeDir)
+	}
 
 	t, err := template.New("config").Parse(StoreConfigTemplate)
 	if err != nil {
@@ -668,11 +679,13 @@ func generateStoreConfig(ctx *gofr.Context, storeName, storeDir string) error {
 	defer file.Close()
 
 	data := struct {
+		StoreName          string
 		PackageName        string
 		OutputDir          string
 		InterfaceName      string
 		ImplementationName string
 	}{
+		StoreName:          storeName,
 		PackageName:        strings.ToLower(storeName),
 		OutputDir:          storeDir,
 		InterfaceName:      cases.Title(language.English).String(storeName) + "Store",
@@ -688,6 +701,44 @@ func generateStoreConfig(ctx *gofr.Context, storeName, storeDir string) error {
 	return nil
 }
 
+// appendToStoreConfig appends a new store to the existing store.yaml.
+func appendToStoreConfig(ctx *gofr.Context, configFile, storeName, storeDir string) error {
+	cfg, err := parseConfigFile(ctx, configFile)
+	if err != nil {
+		return err
+	}
+
+	// Check if store already exists
+	for _, s := range cfg.Stores {
+		if s.Name == storeName {
+			return nil // Already exists
+		}
+	}
+
+	newStore := Info{
+		Name:           storeName,
+		Package:        strings.ToLower(storeName),
+		OutputDir:      storeDir,
+		Interface:      cases.Title(language.English).String(storeName) + "Store",
+		Implementation: strings.ToLower(storeName),
+	}
+
+	cfg.Stores = append(cfg.Stores, newStore)
+
+	data, err := yaml.Marshal(cfg)
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %w", err)
+	}
+
+	if err := os.WriteFile(configFile, data, defaultFilePerm); err != nil {
+		return fmt.Errorf("failed to write config file: %w", err)
+	}
+
+	ctx.Logger.Infof("Appended store %s to config file: %s", storeName, configFile)
+
+	return nil
+}
+
 // generateInitialInterface creates the initial interface.go file.
 func generateInitialInterface(ctx *gofr.Context, storeName, storeDir string) error {
 	interfaceFile := filepath.Join(storeDir, "interface.go")