feat: extensions

api/api/versions.json

@@ -3,11 +3,11 @@
     {
       "version": "v1",
       "status": "active",
-      "release_date": "2025-10-11T20:19:39.955308752+05:30",
+      "release_date": "2025-10-15T21:35:07.482629937+05:30",
       "end_of_life": "0001-01-01T00:00:00Z",
       "changes": [
         "Initial API version"
       ]
     }
   ]
-}
+}

api/internal/features/extension/controller/delete_extension.go

@@ -0,0 +1,24 @@
+package controller
+
+import (
+	"net/http"
+
+	"github.com/go-fuego/fuego"
+	"github.com/raghavyuva/nixopus-api/internal/features/logger"
+)
+
+func (c *ExtensionsController) DeleteFork(ctx fuego.ContextNoBody) (*struct {
+	Status string `json:"status"`
+}, error) {
+	id := ctx.PathParam("id")
+	if id == "" {
+		return nil, fuego.HTTPError{Err: nil, Status: http.StatusBadRequest}
+	}
+	if err := c.service.DeleteFork(id); err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		return nil, fuego.HTTPError{Err: err, Status: http.StatusBadRequest}
+	}
+	return &struct {
+		Status string `json:"status"`
+	}{Status: "ok"}, nil
+}

api/internal/features/extension/controller/fork_extension.go

@@ -0,0 +1,40 @@
+package controller
+
+import (
+	"net/http"
+
+	"github.com/go-fuego/fuego"
+	"github.com/raghavyuva/nixopus-api/internal/features/logger"
+	"github.com/raghavyuva/nixopus-api/internal/types"
+)
+
+type ForkExtensionRequest struct {
+	YAMLContent *string `json:"yaml_content"`
+}
+
+func (c *ExtensionsController) ForkExtension(ctx fuego.ContextWithBody[ForkExtensionRequest]) (types.Extension, error) {
+	extensionID := ctx.PathParam("extension_id")
+	if extensionID == "" {
+		return types.Extension{}, fuego.HTTPError{Err: nil, Status: http.StatusBadRequest}
+	}
+	req, err := ctx.Body()
+	if err != nil {
+		return types.Extension{}, fuego.HTTPError{Err: err, Status: http.StatusBadRequest}
+	}
+	var yamlOverride string
+	if req.YAMLContent != nil {
+		yamlOverride = *req.YAMLContent
+	}
+	authorName := ""
+	if userAny := ctx.Request().Context().Value(types.UserContextKey); userAny != nil {
+		if u, ok := userAny.(*types.User); ok && u != nil {
+			authorName = u.Username
+		}
+	}
+	newExt, err := c.service.ForkExtension(extensionID, yamlOverride, authorName)
+	if err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		return types.Extension{}, fuego.HTTPError{Err: err, Status: http.StatusInternalServerError}
+	}
+	return *newExt, nil
+}

api/internal/features/extension/controller/get_extensions.go

@@ -0,0 +1,167 @@
+package controller
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/go-fuego/fuego"
+	"github.com/raghavyuva/nixopus-api/internal/features/logger"
+	"github.com/raghavyuva/nixopus-api/internal/types"
+)
+
+func (c *ExtensionsController) GetExtensions(ctx fuego.ContextNoBody) (*types.ExtensionListResponse, error) {
+	params := types.ExtensionListParams{}
+
+	categoryParam := ctx.QueryParam("category")
+	if categoryParam != "" {
+		cat := types.ExtensionCategory(categoryParam)
+		params.Category = &cat
+	}
+
+	searchParam := ctx.QueryParam("search")
+	if searchParam != "" {
+		params.Search = searchParam
+	}
+
+	if typeParam := ctx.QueryParam("type"); typeParam != "" {
+		et := types.ExtensionType(typeParam)
+		params.Type = &et
+	}
+
+	sortByParam := ctx.QueryParam("sort_by")
+	if sortByParam != "" {
+		params.SortBy = types.ExtensionSortField(sortByParam)
+	}
+
+	sortDirParam := ctx.QueryParam("sort_dir")
+	if sortDirParam != "" {
+		params.SortDir = types.SortDirection(sortDirParam)
+	}
+
+	pageParam := ctx.QueryParam("page")
+	if pageParam != "" {
+		if page, err := strconv.Atoi(pageParam); err == nil && page > 0 {
+			params.Page = page
+		}
+	}
+
+	pageSizeParam := ctx.QueryParam("page_size")
+	if pageSizeParam != "" {
+		if pageSize, err := strconv.Atoi(pageSizeParam); err == nil && pageSize > 0 {
+			params.PageSize = pageSize
+		}
+	}
+
+	response, err := c.service.ListExtensions(params)
+	if err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		return nil, fuego.HTTPError{
+			Err:    err,
+			Status: http.StatusInternalServerError,
+		}
+	}
+
+	return response, nil
+}
+
+func (c *ExtensionsController) GetCategories(ctx fuego.ContextNoBody) ([]types.ExtensionCategory, error) {
+	cats, err := c.service.ListCategories()
+	if err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		return nil, fuego.HTTPError{Err: err, Status: http.StatusInternalServerError}
+	}
+	return cats, nil
+}
+
+func (c *ExtensionsController) GetExtension(ctx fuego.ContextNoBody) (types.Extension, error) {
+	id := ctx.PathParam("id")
+	if id == "" {
+		return types.Extension{}, fuego.HTTPError{
+			Err:    nil,
+			Status: http.StatusBadRequest,
+		}
+	}
+
+	extension, err := c.service.GetExtension(id)
+	if err != nil {
+		if err.Error() == "extension not found" {
+			return types.Extension{}, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusNotFound,
+			}
+		}
+		c.logger.Log(logger.Error, err.Error(), "")
+		return types.Extension{}, fuego.HTTPError{
+			Err:    err,
+			Status: http.StatusInternalServerError,
+		}
+	}
+
+	return *extension, nil
+}
+
+func (c *ExtensionsController) GetExtensionByExtensionID(ctx fuego.ContextNoBody) (types.Extension, error) {
+	extensionID := ctx.PathParam("extension_id")
+	if extensionID == "" {
+		return types.Extension{}, fuego.HTTPError{
+			Err:    nil,
+			Status: http.StatusBadRequest,
+		}
+	}
+
+	extension, err := c.service.GetExtensionByID(extensionID)
+	if err != nil {
+		if err.Error() == "extension not found" {
+			return types.Extension{}, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusNotFound,
+			}
+		}
+		c.logger.Log(logger.Error, err.Error(), "")
+		return types.Extension{}, fuego.HTTPError{
+			Err:    err,
+			Status: http.StatusInternalServerError,
+		}
+	}
+
+	return *extension, nil
+}
+
+func (c *ExtensionsController) GetExecution(ctx fuego.ContextNoBody) (*types.ExtensionExecution, error) {
+	id := ctx.PathParam("execution_id")
+	if id == "" {
+		return nil, fuego.HTTPError{
+			Err:    nil,
+			Status: http.StatusBadRequest,
+		}
+	}
+
+	exec, err := c.service.GetExecutionByID(id)
+	if err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		return nil, fuego.HTTPError{
+			Err:    err,
+			Status: http.StatusInternalServerError,
+		}
+	}
+	return exec, nil
+}
+
+func (c *ExtensionsController) ListExecutionsByExtensionID(ctx fuego.ContextNoBody) ([]types.ExtensionExecution, error) {
+	extensionID := ctx.PathParam("extension_id")
+	if extensionID == "" {
+		return nil, fuego.HTTPError{
+			Err:    nil,
+			Status: http.StatusBadRequest,
+		}
+	}
+	execs, err := c.service.ListExecutionsByExtensionID(extensionID)
+	if err != nil {
+		c.logger.Log(logger.Error, err.Error(), "")
+		return nil, fuego.HTTPError{
+			Err:    err,
+			Status: http.StatusInternalServerError,
+		}
+	}
+	return execs, nil
+}

api/internal/features/extension/controller/init.go

@@ -0,0 +1,72 @@
+package controller
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/raghavyuva/nixopus-api/internal/features/extension/service"
+	"github.com/raghavyuva/nixopus-api/internal/features/extension/storage"
+	"github.com/raghavyuva/nixopus-api/internal/features/extension/validation"
+	"github.com/raghavyuva/nixopus-api/internal/features/logger"
+	shared_storage "github.com/raghavyuva/nixopus-api/internal/storage"
+	"github.com/raghavyuva/nixopus-api/internal/utils"
+)
+
+type ExtensionsController struct {
+	store     *shared_storage.Store
+	service   *service.ExtensionService
+	validator *validation.Validator
+	ctx       context.Context
+	logger    logger.Logger
+}
+
+func NewExtensionsController(
+	store *shared_storage.Store,
+	ctx context.Context,
+	l logger.Logger,
+) *ExtensionsController {
+	storage := storage.ExtensionStorage{DB: store.DB, Ctx: ctx}
+	return &ExtensionsController{
+		store:     store,
+		service:   service.NewExtensionService(store, ctx, l, &storage),
+		validator: validation.NewValidator(&storage),
+		ctx:       ctx,
+		logger:    l,
+	}
+}
+
+// parseAndValidate parses and validates the request body.
+//
+// This method attempts to parse the request body into the provided 'req' interface
+// using the controller's validator. If parsing fails, an error response is sent
+// and the method returns false. It also validates the parsed request object and
+// returns false if validation fails. If both operations are successful, it returns true.
+//
+// Parameters:
+//
+//	w - the HTTP response writer to send error responses.
+//	r - the HTTP request containing the body to parse.
+//	req - the interface to populate with the parsed request body.
+//
+// Returns:
+//
+//	bool - true if parsing and validation succeed, false otherwise.
+func (c *ExtensionsController) parseAndValidate(w http.ResponseWriter, r *http.Request, req interface{}) bool {
+	if err := c.validator.ParseRequestBody(r, r.Body, req); err != nil {
+		c.logger.Log(logger.Error, "Failed to decode request", err.Error())
+		utils.SendErrorResponse(w, "Failed to decode request", http.StatusBadRequest)
+		return false
+	}
+
+	if err := c.validator.ValidateRequest(req); err != nil {
+		c.logger.Log(logger.Error, err.Error(), err.Error())
+		utils.SendErrorResponse(w, err.Error(), http.StatusBadRequest)
+		return false
+	}
+
+	return true
+}
+
+type RunExtensionRequest struct {
+	Variables map[string]interface{} `json:"variables"`
+}