Merge pull request #106 from raghavyuva/feat/develop

v0.1.0-alpha.6

Author: raghavyuva

api/Makefile

@@ -6,4 +6,10 @@ run: build
 	@./bin/$(APP_NAME)
 
 test:
-	@go test -p 1 ./... -v -count=1
+	@go test -p 1 ./internal/features/... -v -count=1
+
+test-all:
+	@go test -p 1 ./... -v -count=1
+
+test-routes:
+	@go test -p 1 ./internal/tests/routes/... -v -count=1

api/api/versions.json

@@ -3,7 +3,7 @@
     {
       "version": "v1",
       "status": "active",
-      "release_date": "2025-05-20T06:54:40.525772+05:30",
+      "release_date": "2025-05-21T12:13:32.366669+05:30",
       "end_of_life": "0001-01-01T00:00:00Z",
       "changes": [
         "Initial API version"

api/internal/features/deploy/proxy/caddy.go

@@ -72,29 +72,31 @@ func (c *Caddy) Serve() error {
 		Handle: []interface{}{handle},
 	}
 
-	jsonData, err := json.Marshal([]Route{routeConfig})
+	// Get current config
+	config, err := c.GetConfig()
 	if err != nil {
-		return fmt.Errorf("failed to marshal route config: %w", err)
+		return fmt.Errorf("failed to get current config: %w", err)
 	}
 
-	req, err := http.NewRequest("POST", c.Endpoint+"/config/apps/http/servers/nixopus/routes/...", bytes.NewBuffer(jsonData))
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
+	// Replace the route for our domain
+	server := config.Apps.HTTP.Servers["nixopus"]
+	var newRoutes []Route
+	for _, route := range server.Routes {
+		if len(route.Match) > 0 && len(route.Match[0].Host) > 0 && route.Match[0].Host[0] != c.Domain {
+			newRoutes = append(newRoutes, route)
+		}
 	}
-	req.Header.Set("Content-Type", "application/json")
 
-	resp, err := c.client.Do(req)
-	if err != nil {
-		return fmt.Errorf("failed to send request: %w", err)
-	}
-	defer resp.Body.Close()
+	newRoutes = append(newRoutes, routeConfig)
+	server.Routes = newRoutes
+	config.Apps.HTTP.Servers["nixopus"] = server
 
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("failed to append route: %s - %s", resp.Status, string(body))
+	// Update the configuration
+	if err := c.UpdateConfig(config); err != nil {
+		return fmt.Errorf("failed to update caddy configuration: %w", err)
 	}
 
-	c.Logger.Log(logger.Info, "Caddy server started successfully", "")
+	c.Logger.Log(logger.Info, "Caddy server configuration updated successfully", "")
 	return nil
 }
 
@@ -112,33 +114,6 @@ func (c *Caddy) checkCaddyRunning() error {
 	return nil
 }
 
-func (c *Caddy) loadConfig(config CaddyConfig) error {
-	jsonData, err := json.Marshal(config)
-	if err != nil {
-		return fmt.Errorf("failed to marshal config: %w", err)
-	}
-
-	req, err := http.NewRequest("POST", c.Endpoint+"/load", bytes.NewBuffer(jsonData))
-	if err != nil {
-		return fmt.Errorf("failed to create request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Cache-Control", "must-revalidate")
-
-	resp, err := c.client.Do(req)
-	if err != nil {
-		return fmt.Errorf("failed to send request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		body, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("failed to load config: %s - %s", resp.Status, string(body))
-	}
-
-	return nil
-}
-
 func (c *Caddy) Stop() error {
 	req, err := http.NewRequest("POST", c.Endpoint+"/stop", nil)
 	if err != nil {

api/internal/features/feature-flags/storage/init.go

@@ -32,9 +32,16 @@ func NewFeatureFlagStorage(db *bun.DB, ctx context.Context) *FeatureFlagStorage
 	}
 }
 
+func (s *FeatureFlagStorage) getDB() bun.IDB {
+	if s.tx != nil {
+		return s.tx
+	}
+	return s.DB
+}
+
 func (s *FeatureFlagStorage) GetFeatureFlags(organizationID uuid.UUID) ([]types.FeatureFlag, error) {
 	var flags []types.FeatureFlag
-	err := s.DB.NewSelect().
+	err := s.getDB().NewSelect().
 		Model(&flags).
 		Where("organization_id = ?", organizationID).
 		Where("deleted_at IS NULL").
@@ -49,7 +56,7 @@ func (s *FeatureFlagStorage) GetFeatureFlags(organizationID uuid.UUID) ([]types.
 
 func (s *FeatureFlagStorage) UpdateFeatureFlag(organizationID uuid.UUID, featureName string, isEnabled bool) error {
 	flag := &types.FeatureFlag{}
-	err := s.DB.NewSelect().
+	err := s.getDB().NewSelect().
 		Model(flag).
 		Where("organization_id = ?", organizationID).
 		Where("feature_name = ?", featureName).
@@ -66,15 +73,15 @@ func (s *FeatureFlagStorage) UpdateFeatureFlag(organizationID uuid.UUID, feature
 				CreatedAt:      time.Now(),
 				UpdatedAt:      time.Now(),
 			}
-			_, err = s.DB.NewInsert().Model(flag).Exec(s.Ctx)
+			_, err = s.getDB().NewInsert().Model(flag).Exec(s.Ctx)
 			return err
 		}
 		return fmt.Errorf("failed to get feature flag: %w", err)
 	}
 
 	flag.IsEnabled = isEnabled
 	flag.UpdatedAt = time.Now()
-	_, err = s.DB.NewUpdate().
+	_, err = s.getDB().NewUpdate().
 		Model(flag).
 		Where("id = ?", flag.ID).
 		Exec(s.Ctx)
@@ -84,7 +91,7 @@ func (s *FeatureFlagStorage) UpdateFeatureFlag(organizationID uuid.UUID, feature
 
 func (s *FeatureFlagStorage) IsFeatureEnabled(organizationID uuid.UUID, featureName string) (bool, error) {
 	var isEnabled bool
-	err := s.DB.NewSelect().
+	err := s.getDB().NewSelect().
 		TableExpr("feature_flags").
 		Column("is_enabled").
 		Where("organization_id = ?", organizationID).
@@ -103,7 +110,7 @@ func (s *FeatureFlagStorage) IsFeatureEnabled(organizationID uuid.UUID, featureN
 }
 
 func (s *FeatureFlagStorage) CreateFeatureFlag(featureFlag types.FeatureFlag) error {
-	_, err := s.DB.NewInsert().Model(&featureFlag).Exec(s.Ctx)
+	_, err := s.getDB().NewInsert().Model(&featureFlag).Exec(s.Ctx)
 	return err
 }
 

api/internal/features/feature-flags/tests/feature_flag_storage_test.go

@@ -0,0 +1,144 @@
+package tests
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/raghavyuva/nixopus-api/internal/features/feature-flags/storage"
+	"github.com/raghavyuva/nixopus-api/internal/testutils"
+	"github.com/raghavyuva/nixopus-api/internal/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFeatureFlagStorage(t *testing.T) {
+	t.Run("should create and get feature flag", func(t *testing.T) {
+		setup := testutils.NewTestSetup()
+		featureStorage := &storage.FeatureFlagStorage{DB: setup.DB, Ctx: setup.Ctx}
+
+		_, org, err := setup.CreateTestUserAndOrg()
+		assert.NoError(t, err)
+
+		featureFlag := types.FeatureFlag{
+			ID:             uuid.New(),
+			OrganizationID: org.ID,
+			FeatureName:    string(types.FeatureDomain),
+			IsEnabled:      true,
+			CreatedAt:      time.Now(),
+			UpdatedAt:      time.Now(),
+		}
+
+		err = featureStorage.CreateFeatureFlag(featureFlag)
+		assert.NoError(t, err)
+
+		flags, err := featureStorage.GetFeatureFlags(org.ID)
+		assert.NoError(t, err)
+		assert.Len(t, flags, 1)
+		assert.Equal(t, featureFlag.FeatureName, flags[0].FeatureName)
+		assert.Equal(t, featureFlag.IsEnabled, flags[0].IsEnabled)
+	})
+
+	t.Run("should update existing feature flag", func(t *testing.T) {
+		setup := testutils.NewTestSetup()
+		featureStorage := &storage.FeatureFlagStorage{DB: setup.DB, Ctx: setup.Ctx}
+
+		_, org, err := setup.CreateTestUserAndOrg()
+		assert.NoError(t, err)
+
+		featureFlag := types.FeatureFlag{
+			ID:             uuid.New(),
+			OrganizationID: org.ID,
+			FeatureName:    string(types.FeatureDomain),
+			IsEnabled:      true,
+			CreatedAt:      time.Now(),
+			UpdatedAt:      time.Now(),
+		}
+
+		err = featureStorage.CreateFeatureFlag(featureFlag)
+		assert.NoError(t, err)
+
+		err = featureStorage.UpdateFeatureFlag(org.ID, string(types.FeatureDomain), false)
+		assert.NoError(t, err)
+
+		isEnabled, err := featureStorage.IsFeatureEnabled(org.ID, string(types.FeatureDomain))
+		assert.NoError(t, err)
+		assert.False(t, isEnabled)
+	})
+
+	t.Run("should create new feature flag on update if not exists", func(t *testing.T) {
+		setup := testutils.NewTestSetup()
+		featureStorage := &storage.FeatureFlagStorage{DB: setup.DB, Ctx: setup.Ctx}
+
+		_, org, err := setup.CreateTestUserAndOrg()
+		assert.NoError(t, err)
+
+		err = featureStorage.UpdateFeatureFlag(org.ID, string(types.FeatureDomain), true)
+		assert.NoError(t, err)
+
+		flags, err := featureStorage.GetFeatureFlags(org.ID)
+		assert.NoError(t, err)
+		assert.Len(t, flags, 1)
+		assert.Equal(t, string(types.FeatureDomain), flags[0].FeatureName)
+		assert.True(t, flags[0].IsEnabled)
+	})
+
+	t.Run("should handle transaction operations", func(t *testing.T) {
+		setup := testutils.NewTestSetup()
+		featureStorage := &storage.FeatureFlagStorage{DB: setup.DB, Ctx: setup.Ctx}
+
+		_, org, err := setup.CreateTestUserAndOrg()
+		assert.NoError(t, err)
+
+		tx, err := featureStorage.BeginTx()
+		assert.NoError(t, err)
+		defer tx.Rollback()
+
+		txStorage := featureStorage.WithTx(tx)
+
+		err = txStorage.UpdateFeatureFlag(org.ID, string(types.FeatureDomain), true)
+		assert.NoError(t, err)
+
+		err = txStorage.UpdateFeatureFlag(org.ID, string(types.FeatureTerminal), false)
+		assert.NoError(t, err)
+
+		err = tx.Commit()
+		assert.NoError(t, err)
+
+		flags, err := featureStorage.GetFeatureFlags(org.ID)
+		assert.NoError(t, err)
+		assert.Len(t, flags, 2)
+
+		domainEnabled, err := featureStorage.IsFeatureEnabled(org.ID, string(types.FeatureDomain))
+		assert.NoError(t, err)
+		assert.True(t, domainEnabled)
+
+		terminalEnabled, err := featureStorage.IsFeatureEnabled(org.ID, string(types.FeatureTerminal))
+		assert.NoError(t, err)
+		assert.True(t, terminalEnabled)
+	})
+
+	t.Run("should rollback transaction on error", func(t *testing.T) {
+		setup := testutils.NewTestSetup()
+		featureStorage := &storage.FeatureFlagStorage{DB: setup.DB, Ctx: setup.Ctx}
+
+		_, org, err := setup.CreateTestUserAndOrg()
+		assert.NoError(t, err)
+
+		tx, err := featureStorage.BeginTx()
+		assert.NoError(t, err)
+		defer tx.Rollback()
+
+		txStorage := featureStorage.WithTx(tx)
+
+		err = txStorage.UpdateFeatureFlag(org.ID, string(types.FeatureDomain), true)
+		assert.NoError(t, err)
+
+		err = txStorage.UpdateFeatureFlag(uuid.Nil, string(types.FeatureTerminal), false)
+		assert.Error(t, err)
+
+		// Transaction should be rolled back
+		flags, err := featureStorage.GetFeatureFlags(org.ID)
+		assert.NoError(t, err)
+		assert.Empty(t, flags)
+	})
+}