openwork-agent 1.0.0

package/src/templates/go/basic/config/config.go.hbs

@@ -0,0 +1,54 @@
+package config
+
+import (
+	"log"
+	"os"
+	"strconv"
+)
+
+type Config struct {
+	ServerPort    string
+	DatabaseURL   string
+	DatabaseName  string
+	JWTSecret     string
+	Environment   string
+}
+
+var AppConfig *Config
+
+func LoadConfig() {
+	AppConfig = &Config{
+		ServerPort:   getEnv("PORT", "8080"),
+		DatabaseURL:  getEnv("DATABASE_URL", "mongodb://localhost:27017"),
+		DatabaseName: getEnv("DB_NAME", "{{projectName}}"),
+		JWTSecret:    getEnv("JWT_SECRET", "your-secret-key"),
+		Environment:  getEnv("ENVIRONMENT", "development"),
+	}
+
+	log.Printf("Configuration loaded for environment: %s", AppConfig.Environment)
+}
+
+func getEnv(key, defaultValue string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return defaultValue
+}
+
+func getEnvAsInt(key string, defaultValue int) int {
+	if valueStr := os.Getenv(key); valueStr != "" {
+		if value, err := strconv.Atoi(valueStr); err == nil {
+			return value
+		}
+	}
+	return defaultValue
+}
+
+func getEnvAsBool(key string, defaultValue bool) bool {
+	if valueStr := os.Getenv(key); valueStr != "" {
+		if value, err := strconv.ParseBool(valueStr); err == nil {
+			return value
+		}
+	}
+	return defaultValue
+}

package/src/templates/go/basic/go.mod.hbs

@@ -0,0 +1,8 @@
+module {{projectName}}
+
+go 1.21
+
+require (
+	github.com/gin-gonic/gin v1.9.1
+	go.mongodb.org/mongo-driver v1.12.1
+)

package/src/templates/go/basic/main.go.hbs

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"log"
+	"os"
+
+	"{{projectName}}/api/routes"
+	"{{projectName}}/config"
+	"{{projectName}}/models"
+	
+	"github.com/gin-gonic/gin"
+)
+
+func main() {
+	// Load configuration
+	config.LoadConfig()
+
+	// Initialize database
+	if err := models.ConnectDatabase(); err != nil {
+		log.Fatal("Failed to connect to database:", err)
+	}
+
+	// Set Gin mode
+	if os.Getenv("GIN_MODE") == "release" {
+		gin.SetMode(gin.ReleaseMode)
+	}
+
+	// Create Gin router
+	r := gin.Default()
+
+	// Add middleware
+	r.Use(gin.Logger())
+	r.Use(gin.Recovery())
+
+	// CORS middleware
+	r.Use(func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Origin", "*")
+		c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		c.Header("Access-Control-Allow-Headers", "Content-Type, Authorization")
+		
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
+			return
+		}
+		
+		c.Next()
+	})
+
+	// Health check endpoint
+	r.GET("/health", func(c *gin.Context) {
+		c.JSON(200, gin.H{
+			"status": "OK",
+			"timestamp": "2024-01-01T00:00:00Z",
+		})
+	})
+
+	// Setup routes
+	api := r.Group("/api")
+	routes.SetupRoutes(api)
+
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "8080"
+	}
+
+	log.Printf("🚀 Server starting on port %s", port)
+	if err := r.Run(":" + port); err != nil {
+		log.Fatal("Failed to start server:", err)
+	}
+}

package/src/templates/go/basic/models/user.go.hbs

@@ -0,0 +1,69 @@
+package models
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"{{projectName}}/config"
+
+	"go.mongodb.org/mongo-driver/mongo"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+var DB *mongo.Database
+
+type User struct {
+	ID        string    `json:"id" bson:"_id,omitempty"`
+	Name      string    `json:"name" bson:"name"`
+	Email     string    `json:"email" bson:"email"`
+	Age       *int      `json:"age" bson:"age,omitempty"`
+	CreatedAt time.Time `json:"created_at" bson:"created_at"`
+	UpdatedAt time.Time `json:"updated_at" bson:"updated_at"`
+}
+
+func ConnectDatabase() error {
+	clientOptions := options.Client().ApplyURI(config.AppConfig.DatabaseURL)
+	client, err := mongo.Connect(context.Background(), clientOptions)
+	
+	if err != nil {
+		return err
+	}
+
+	// Check the connection
+	err = client.Ping(context.Background(), nil)
+	if err != nil {
+		return err
+	}
+
+	DB = client.Database(config.AppConfig.DatabaseName)
+	log.Println("✅ Connected to MongoDB")
+
+	// Create indexes
+	if err := createIndexes(); err != nil {
+		log.Printf("Warning: Failed to create indexes: %v", err)
+	}
+
+	return nil
+}
+
+func createIndexes() error {
+	userCollection := DB.Collection("users")
+	
+	// Create unique index on email
+	indexModel := mongo.IndexModel{
+		Keys: map[string]int{"email": 1},
+		Options: options.Index().SetUnique(true),
+	}
+	
+	_, err := userCollection.Indexes().CreateOne(context.Background(), indexModel)
+	return err
+}
+
+func (u *User) PreSave() {
+	now := time.Now()
+	if u.CreatedAt.IsZero() {
+		u.CreatedAt = now
+	}
+	u.UpdatedAt = now
+}

package/src/templates/go/basic/services/user_service.go.hbs

@@ -0,0 +1,173 @@
+package services
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"{{projectName}}/models"
+
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+type UserService struct {
+	collection *mongo.Collection
+}
+
+func NewUserService() *UserService {
+	return &UserService{
+		collection: models.DB.Collection("users"),
+	}
+}
+
+func (s *UserService) GetAllUsers() ([]models.User, error) {
+	var users []models.User
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	cursor, err := s.collection.Find(ctx, bson.M{})
+	if err != nil {
+		return nil, err
+	}
+	defer cursor.Close(ctx)
+
+	for cursor.Next(ctx) {
+		var user models.User
+		if err := cursor.Decode(&user); err != nil {
+			return nil, err
+		}
+		users = append(users, user)
+	}
+
+	if err := cursor.Err(); err != nil {
+		return nil, err
+	}
+
+	return users, nil
+}
+
+func (s *UserService) GetUserByID(id string) (*models.User, error) {
+	objectID, err := primitive.ObjectIDFromHex(id)
+	if err != nil {
+		return nil, fmt.Errorf("invalid user ID")
+	}
+
+	var user models.User
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	err = s.collection.FindOne(ctx, bson.M{"_id": objectID}).Decode(&user)
+	if err != nil {
+		if err == mongo.ErrNoDocuments {
+			return nil, fmt.Errorf("user not found")
+		}
+		return nil, err
+	}
+
+	return &user, nil
+}
+
+func (s *UserService) CreateUser(user *models.User) (*models.User, error) {
+	user.PreSave()
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	result, err := s.collection.InsertOne(ctx, user)
+	if err != nil {
+		return nil, err
+	}
+
+	user.ID = result.InsertedID.(primitive.ObjectID).Hex()
+	return user, nil
+}
+
+func (s *UserService) UpdateUser(id string, user *models.User) (*models.User, error) {
+	objectID, err := primitive.ObjectIDFromHex(id)
+	if err != nil {
+		return nil, fmt.Errorf("invalid user ID")
+	}
+
+	user.PreSave()
+	
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	update := bson.M{
+		"$set": bson.M{
+			"name":       user.Name,
+			"email":      user.Email,
+			"age":        user.Age,
+			"updated_at": user.UpdatedAt,
+		},
+	}
+
+	var updatedUser models.User
+	err = s.collection.FindOneAndUpdate(
+		ctx,
+		bson.M{"_id": objectID},
+		update,
+	).Decode(&updatedUser)
+
+	if err != nil {
+		if err == mongo.ErrNoDocuments {
+			return nil, fmt.Errorf("user not found")
+		}
+		return nil, err
+	}
+
+	return &updatedUser, nil
+}
+
+func (s *UserService) DeleteUser(id string) error {
+	objectID, err := primitive.ObjectIDFromHex(id)
+	if err != nil {
+		return fmt.Errorf("invalid user ID")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	result, err := s.collection.DeleteOne(ctx, bson.M{"_id": objectID})
+	if err != nil {
+		return err
+	}
+
+	if result.DeletedCount == 0 {
+		return fmt.Errorf("user not found")
+	}
+
+	return nil
+}
+
+func (s *UserService) GetUserByEmail(email string) (*models.User, error) {
+	var user models.User
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	err := s.collection.FindOne(ctx, bson.M{"email": email}).Decode(&user)
+	if err != nil {
+		if err == mongo.ErrNoDocuments {
+			return nil, fmt.Errorf("user not found")
+		}
+		return nil, err
+	}
+
+	return &user, nil
+}
+
+func (s *UserService) UserExists(email string) (bool, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	count, err := s.collection.CountDocuments(ctx, bson.M{"email": email})
+	if err != nil {
+		return false, err
+	}
+
+	return count > 0, nil
+}

package/src/templates/java/basic/src/main/java/com/{{snakeCase projectName}}/{{projectName}}/controller/UserController.java.hbs

@@ -0,0 +1,91 @@
+package com.{{snakeCase projectName}}.{{projectName}}.controller;
+
+import com.{{snakeCase projectName}}.{{projectName}}.model.User;
+import com.{{snakeCase projectName}}.{{projectName}}.service.UserService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Optional;
+
+@RestController
+@RequestMapping("/api/users")
+@CrossOrigin(origins = "*")
+public class UserController {
+
+    @Autowired
+    private UserService userService;
+
+    @GetMapping
+    public ResponseEntity<ApiResponse<List<User>>> getAllUsers() {
+        try {
+            List<User> users = userService.getAllUsers();
+            return ResponseEntity.ok(new ApiResponse<>(true, users, "Users retrieved successfully"));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(new ApiResponse<>(false, null, "Failed to retrieve users: " + e.getMessage()));
+        }
+    }
+
+    @GetMapping("/{id}")
+    public ResponseEntity<ApiResponse<User>> getUserById(@PathVariable String id) {
+        try {
+            Optional<User> user = userService.getUserById(id);
+            if (user.isPresent()) {
+                return ResponseEntity.ok(new ApiResponse<>(true, user.get(), "User retrieved successfully"));
+            } else {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                        .body(new ApiResponse<>(false, null, "User not found"));
+            }
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(new ApiResponse<>(false, null, "Failed to retrieve user: " + e.getMessage()));
+        }
+    }
+
+    @PostMapping
+    public ResponseEntity<ApiResponse<User>> createUser(@RequestBody User user) {
+        try {
+            User createdUser = userService.createUser(user);
+            return ResponseEntity.status(HttpStatus.CREATED)
+                    .body(new ApiResponse<>(true, createdUser, "User created successfully"));
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(new ApiResponse<>(false, null, "Failed to create user: " + e.getMessage()));
+        }
+    }
+
+    @PutMapping("/{id}")
+    public ResponseEntity<ApiResponse<User>> updateUser(@PathVariable String id, @RequestBody User user) {
+        try {
+            User updatedUser = userService.updateUser(id, user);
+            if (updatedUser != null) {
+                return ResponseEntity.ok(new ApiResponse<>(true, updatedUser, "User updated successfully"));
+            } else {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                        .body(new ApiResponse<>(false, null, "User not found"));
+            }
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(new ApiResponse<>(false, null, "Failed to update user: " + e.getMessage()));
+        }
+    }
+
+    @DeleteMapping("/{id}")
+    public ResponseEntity<ApiResponse<Void>> deleteUser(@PathVariable String id) {
+        try {
+            boolean deleted = userService.deleteUser(id);
+            if (deleted) {
+                return ResponseEntity.ok(new ApiResponse<>(true, null, "User deleted successfully"));
+            } else {
+                return ResponseEntity.status(HttpStatus.NOT_FOUND)
+                        .body(new ApiResponse<>(false, null, "User not found"));
+            }
+        } catch (Exception e) {
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
+                    .body(new ApiResponse<>(false, null, "Failed to delete user: " + e.getMessage()));
+        }
+    }
+}

package/src/templates/java/basic/src/main/java/com/{{snakeCase projectName}}/{{projectName}}/dto/ApiResponse.java.hbs

@@ -0,0 +1,40 @@
+package com.{{snakeCase projectName}}.{{projectName}}.dto;
+
+public class ApiResponse<T> {
+    private boolean success;
+    private T data;
+    private String message;
+
+    public ApiResponse() {}
+
+    public ApiResponse(boolean success, T data, String message) {
+        this.success = success;
+        this.data = data;
+        this.message = message;
+    }
+
+    // Getters and Setters
+    public boolean isSuccess() {
+        return success;
+    }
+
+    public void setSuccess(boolean success) {
+        this.success = success;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    public void setData(T data) {
+        this.data = data;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+}

package/src/templates/java/basic/src/main/java/com/{{snakeCase projectName}}/{{projectName}}/model/User.java.hbs

@@ -0,0 +1,102 @@
+package com.{{snakeCase projectName}}.{{projectName}}.model;
+
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.mapping.Document;
+import org.springframework.data.mongodb.core.mapping.Field;
+import java.time.LocalDateTime;
+
+@Document(collection = "users")
+public class User {
+
+    @Id
+    private String id;
+
+    private String name;
+
+    private String email;
+
+    private Integer age;
+
+    @Field("created_at")
+    private LocalDateTime createdAt;
+
+    @Field("updated_at")
+    private LocalDateTime updatedAt;
+
+    // Constructors
+    public User() {
+        this.createdAt = LocalDateTime.now();
+        this.updatedAt = LocalDateTime.now();
+    }
+
+    public User(String name, String email, Integer age) {
+        this();
+        this.name = name;
+        this.email = email;
+        this.age = age;
+    }
+
+    // Getters and Setters
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+        this.updatedAt = LocalDateTime.now();
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+        this.updatedAt = LocalDateTime.now();
+    }
+
+    public Integer getAge() {
+        return age;
+    }
+
+    public void setAge(Integer age) {
+        this.age = age;
+        this.updatedAt = LocalDateTime.now();
+    }
+
+    public LocalDateTime getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(LocalDateTime createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public LocalDateTime getUpdatedAt() {
+        return updatedAt;
+    }
+
+    public void setUpdatedAt(LocalDateTime updatedAt) {
+        this.updatedAt = updatedAt;
+    }
+
+    @Override
+    public String toString() {
+        return "User{" +
+                "id='" + id + '\'' +
+                ", name='" + name + '\'' +
+                ", email='" + email + '\'' +
+                ", age=" + age +
+                ", createdAt=" + createdAt +
+                ", updatedAt=" + updatedAt +
+                '}';
+    }
+}

package/src/templates/java/basic/src/main/java/com/{{snakeCase projectName}}/{{projectName}}/repository/UserRepository.java.hbs

@@ -0,0 +1,20 @@
+package com.{{snakeCase projectName}}.{{projectName}}.repository;
+
+import com.{{snakeCase projectName}}.{{projectName}}.model.User;
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+@Repository
+public interface UserRepository extends MongoRepository<User, String> {
+    
+    Optional<User> findByEmail(String email);
+    
+    List<User> findByNameContainingIgnoreCase(String name);
+    
+    boolean existsByEmail(String email);
+    
+    void deleteByEmail(String email);
+}

package/src/templates/java/basic/src/main/java/com/{{snakeCase projectName}}/{{projectName}}/service/UserService.java.hbs

@@ -0,0 +1,65 @@
+package com.{{snakeCase projectName}}.{{projectName}}.service;
+
+import com.{{snakeCase projectName}}.{{projectName}}.model.User;
+import com.{{snakeCase projectName}}.{{projectName}}.repository.UserRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Optional;
+
+@Service
+public class UserService {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    public List<User> getAllUsers() {
+        return userRepository.findAll();
+    }
+
+    public Optional<User> getUserById(String id) {
+        return userRepository.findById(id);
+    }
+
+    public User createUser(User user) {
+        user.setCreatedAt(LocalDateTime.now());
+        user.setUpdatedAt(LocalDateTime.now());
+        return userRepository.save(user);
+    }
+
+    public User updateUser(String id, User userDetails) {
+        Optional<User> optionalUser = userRepository.findById(id);
+        
+        if (optionalUser.isPresent()) {
+            User user = optionalUser.get();
+            user.setName(userDetails.getName() != null ? userDetails.getName() : user.getName());
+            user.setEmail(userDetails.getEmail() != null ? userDetails.getEmail() : user.getEmail());
+            user.setAge(userDetails.getAge() != null ? userDetails.getAge() : user.getAge());
+            user.setUpdatedAt(LocalDateTime.now());
+            return userRepository.save(user);
+        }
+        return null;
+    }
+
+    public boolean deleteUser(String id) {
+        if (userRepository.existsById(id)) {
+            userRepository.deleteById(id);
+            return true;
+        }
+        return false;
+    }
+
+    public Optional<User> getUserByEmail(String email) {
+        return userRepository.findByEmail(email);
+    }
+
+    public List<User> getUsersByName(String name) {
+        return userRepository.findByNameContainingIgnoreCase(name);
+    }
+
+    public boolean userExists(String email) {
+        return userRepository.existsByEmail(email);
+    }
+}