feat : Nixopus CLI

.gitignore

@@ -12,3 +12,47 @@ docs/.vitepress/cache
 .env.staging
 !api/.env.sample
 **.log
+.vscode
+
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+.venv/
+
+.idea/
+
+.pytest_cache/
+.coverage
+htmlcov/
+
+.ipynb_checkpoints
+
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local

api/api/versions.json

@@ -3,7 +3,7 @@
     {
       "version": "v1",
       "status": "active",
-      "release_date": "2025-06-30T20:48:43.246107+05:30",
+      "release_date": "2025-07-05T21:25:27.672646+05:30",
       "end_of_life": "0001-01-01T00:00:00Z",
       "changes": [
         "Initial API version"

api/internal/features/domain/controller/create_domain.go

@@ -42,6 +42,21 @@ func (c *DomainsController) CreateDomain(f fuego.ContextWithBody[types.CreateDom
 
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
+
+		if isInvalidDomainError(err) {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusBadRequest,
+			}
+		}
+
+		if err == types.ErrDomainAlreadyExists {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusConflict,
+			}
+		}
+
 		return nil, fuego.HTTPError{
 			Err:    err,
 			Status: http.StatusInternalServerError,

api/internal/features/domain/controller/delete_domain.go

@@ -31,6 +31,21 @@ func (c *DomainsController) DeleteDomain(f fuego.ContextWithBody[types.DeleteDom
 	err = c.service.DeleteDomain(domainRequest.ID)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
+
+		if isInvalidDomainError(err) {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusBadRequest,
+			}
+		}
+
+		if err == types.ErrDomainNotFound {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusNotFound,
+			}
+		}
+
 		return nil, fuego.HTTPError{
 			Err:    err,
 			Status: http.StatusInternalServerError,

api/internal/features/domain/controller/error_helpers.go

@@ -0,0 +1,27 @@
+package controller
+
+import "github.com/raghavyuva/nixopus-api/internal/features/domain/types"
+
+func isInvalidDomainError(err error) bool {
+	switch err {
+	case types.ErrInvalidDomainID,
+		types.ErrMissingDomainID,
+		types.ErrDomainNameInvalid,
+		types.ErrDomainNameTooLong,
+		types.ErrDomainNameTooShort,
+		types.ErrMissingDomainName:
+		return true
+	default:
+		return false
+	}
+}
+
+func isPermissionError(err error) bool {
+	switch err {
+	case types.ErrUserDoesNotBelongToOrganization,
+		types.ErrPermissionDenied:
+		return true
+	default:
+		return false
+	}
+}

api/internal/features/domain/controller/get_domains.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/go-fuego/fuego"
+	"github.com/google/uuid"
 	"github.com/raghavyuva/nixopus-api/internal/features/domain/types"
 	"github.com/raghavyuva/nixopus-api/internal/features/logger"
 	"github.com/raghavyuva/nixopus-api/internal/utils"
@@ -15,24 +16,46 @@ import (
 )
 
 func (c *DomainsController) GetDomains(f fuego.ContextNoBody) (*shared_types.Response, error) {
-	organization_id := f.QueryParam("id")
-
 	w, r := f.Response(), f.Request()
 
-	user := utils.GetUser(w, r)
+	organization_id := utils.GetOrganizationID(r)
+	if organization_id == uuid.Nil {
+		c.logger.Log(logger.Error, "invalid organization id", "")
+		return nil, fuego.HTTPError{
+			Err:    types.ErrMissingID,
+			Status: http.StatusBadRequest,
+		}
+	}
 
+	user := utils.GetUser(w, r)
 	if user == nil {
+		c.logger.Log(logger.Error, "unauthorized user", "")
 		return nil, fuego.HTTPError{
-			Err:    nil,
+			Err:    types.ErrAccessDenied,
 			Status: http.StatusUnauthorized,
 		}
 	}
 
 	c.logger.Log(logger.Info, "fetching domains", fmt.Sprintf("organization_id: %s", organization_id))
 
-	domains, err := c.service.GetDomains(organization_id, user.ID)
+	domains, err := c.service.GetDomains(organization_id.String(), user.ID)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
+
+		if isPermissionError(err) {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusForbidden,
+			}
+		}
+
+		if err == types.ErrDomainNotFound {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusNotFound,
+			}
+		}
+
 		return nil, fuego.HTTPError{
 			Err:    err,
 			Status: http.StatusInternalServerError,
@@ -49,22 +72,53 @@ func (c *DomainsController) GetDomains(f fuego.ContextNoBody) (*shared_types.Res
 func (c *DomainsController) GenerateRandomSubDomain(f fuego.ContextNoBody) (*shared_types.Response, error) {
 	w, r := f.Response(), f.Request()
 
-	organization_id := f.QueryParam("id")
+	organization_id := utils.GetOrganizationID(r)
+	if organization_id == uuid.Nil {
+		c.logger.Log(logger.Error, "invalid organization id", "")
+		return nil, fuego.HTTPError{
+			Err:    types.ErrMissingID,
+			Status: http.StatusBadRequest,
+		}
+	}
+
+	user := utils.GetUser(w, r)
+	if user == nil {
+		c.logger.Log(logger.Error, "unauthorized user", "")
+		return nil, fuego.HTTPError{
+			Err:    types.ErrAccessDenied,
+			Status: http.StatusUnauthorized,
+		}
+	}
 
-	domains, err := c.service.GetDomains(organization_id, utils.GetUser(w, r).ID)
+	domains, err := c.service.GetDomains(organization_id.String(), user.ID)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
+
+		if isPermissionError(err) {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusForbidden,
+			}
+		}
+
+		if err == types.ErrDomainNotFound {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusNotFound,
+			}
+		}
+
 		return nil, fuego.HTTPError{
 			Err:    err,
 			Status: http.StatusInternalServerError,
 		}
 	}
 
 	if len(domains) == 0 {
-		c.logger.Log(logger.Error, "no domains available", "")
+		c.logger.Log(logger.Error, "no domains available for subdomain generation", "")
 		return nil, fuego.HTTPError{
-			Err:    nil,
-			Status: http.StatusBadRequest,
+			Err:    types.ErrDomainNotFound,
+			Status: http.StatusNotFound,
 		}
 	}
 

api/internal/features/domain/controller/update_domain.go

@@ -41,6 +41,21 @@ func (c *DomainsController) UpdateDomain(f fuego.ContextWithBody[types.UpdateDom
 	updated, err := c.service.UpdateDomain(domainRequest.Name, user.ID.String(), domainRequest.ID)
 	if err != nil {
 		c.logger.Log(logger.Error, err.Error(), "")
+
+		if isInvalidDomainError(err) {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusBadRequest,
+			}
+		}
+
+		if err == types.ErrDomainNotFound {
+			return nil, fuego.HTTPError{
+				Err:    err,
+				Status: http.StatusNotFound,
+			}
+		}
+
 		return nil, fuego.HTTPError{
 			Err:    err,
 			Status: http.StatusInternalServerError,

api/internal/features/domain/storage/init.go

@@ -60,7 +60,7 @@ func (s *DomainStorage) CreateDomain(domain *shared_types.Domain) error {
 
 func (s *DomainStorage) GetDomain(id string) (*shared_types.Domain, error) {
 	var domain shared_types.Domain
-	err := s.getDB().NewSelect().Model(&domain).Where("id = ?", id).Scan(s.Ctx)
+	err := s.getDB().NewSelect().Model(&domain).Where("id = ? AND deleted_at IS NULL", id).Scan(s.Ctx)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return nil, types.ErrDomainNotFound
@@ -72,31 +72,46 @@ func (s *DomainStorage) GetDomain(id string) (*shared_types.Domain, error) {
 
 func (s *DomainStorage) UpdateDomain(ID string, Name string) error {
 	var domain shared_types.Domain
-	err := s.getDB().NewSelect().Model(&domain).Where("id = ?", ID).Scan(s.Ctx)
+	err := s.getDB().NewSelect().Model(&domain).Where("id = ? AND deleted_at IS NULL", ID).Scan(s.Ctx)
 	if err != nil {
 		return err
 	}
 	domain.Name = Name
 	domain.UpdatedAt = time.Now()
-	_, err = s.getDB().NewUpdate().Model(&domain).Where("id = ?", ID).Exec(s.Ctx)
+	_, err = s.getDB().NewUpdate().Model(&domain).Where("id = ? AND deleted_at IS NULL", ID).Exec(s.Ctx)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
 func (s *DomainStorage) DeleteDomain(domain *shared_types.Domain) error {
-	_, err := s.getDB().NewDelete().Model(domain).Where("id = ?", domain.ID).Exec(s.Ctx)
+	now := time.Now()
+	result, err := s.getDB().NewUpdate().Model(domain).
+		Set("deleted_at = ?", now).
+		Set("updated_at = ?", now).
+		Where("id = ? AND deleted_at IS NULL", domain.ID).
+		Exec(s.Ctx)
 	if err != nil {
 		return err
 	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if rowsAffected == 0 {
+		return types.ErrDomainNotFound
+	}
+
 	return nil
 }
 
 func (s *DomainStorage) GetDomains(OrganizationID string, UserID uuid.UUID) ([]shared_types.Domain, error) {
 	var domains []shared_types.Domain
 	err := s.getDB().NewSelect().Model(&domains).
-		Where("organization_id = ?", OrganizationID).
+		Where("organization_id = ? AND deleted_at IS NULL", OrganizationID).
 		Scan(s.Ctx)
 	if err != nil {
 		return nil, err
@@ -107,7 +122,7 @@ func (s *DomainStorage) GetDomains(OrganizationID string, UserID uuid.UUID) ([]s
 func (s *DomainStorage) GetDomainByName(name string, organizationID uuid.UUID) (*shared_types.Domain, error) {
 	var domain shared_types.Domain
 	err := s.getDB().NewSelect().Model(&domain).
-		Where("name = ? AND organization_id = ?", name, organizationID).
+		Where("name = ? AND organization_id = ? AND deleted_at IS NULL", name, organizationID).
 		Scan(s.Ctx)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
@@ -120,7 +135,7 @@ func (s *DomainStorage) GetDomainByName(name string, organizationID uuid.UUID) (
 
 func (s *DomainStorage) IsDomainExists(ID string) (bool, error) {
 	var domain shared_types.Domain
-	err := s.getDB().NewSelect().Model(&domain).Where("id = ?", ID).Scan(s.Ctx)
+	err := s.getDB().NewSelect().Model(&domain).Where("id = ? AND deleted_at IS NULL", ID).Scan(s.Ctx)
 	if err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return false, nil
@@ -132,7 +147,7 @@ func (s *DomainStorage) IsDomainExists(ID string) (bool, error) {
 
 func (s *DomainStorage) GetDomainOwnerByID(ID string) (string, error) {
 	var domain shared_types.Domain
-	err := s.getDB().NewSelect().Model(&domain).Where("id = ?", ID).Scan(s.Ctx)
+	err := s.getDB().NewSelect().Model(&domain).Where("id = ? AND deleted_at IS NULL", ID).Scan(s.Ctx)
 	if err != nil {
 		return "", err
 	}