Fix browser-based SDK compatibility

- Fix CORS Failure for JavaScript SDK
- Fix 404 Not Found for Client-Side Endpoints
- Fix incorrect Project Lookup Logic
- Add Performance, Caching, and Database migration
- Add tests for new functionality

Author: brooswit

internal/dev_server/db/sqlite.go

@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"io"
 	"os"
+	"strings"
 
 	_ "github.com/mattn/go-sqlite3"
 	"github.com/pkg/errors"
@@ -47,12 +48,12 @@ func (s *Sqlite) GetDevProject(ctx context.Context, key string) (*model.Project,
 	var flagStateData string
 
 	row := s.database.QueryRowContext(ctx, `
-        SELECT key, source_environment_key, context, last_sync_time, flag_state 
+        SELECT key, source_environment_key, client_side_id, context, last_sync_time, flag_state 
         FROM projects 
         WHERE key = ?
     `, key)
 
-	if err := row.Scan(&project.Key, &project.SourceEnvironmentKey, &contextData, &project.LastSyncTime, &flagStateData); err != nil {
+	if err := row.Scan(&project.Key, &project.SourceEnvironmentKey, &project.ClientSideId, &contextData, &project.LastSyncTime, &flagStateData); err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return nil, model.NewErrNotFound("project", key)
 		}
@@ -72,6 +73,37 @@ func (s *Sqlite) GetDevProject(ctx context.Context, key string) (*model.Project,
 	return &project, nil
 }
 
+func (s *Sqlite) GetDevProjectByClientSideId(ctx context.Context, clientSideId string) (*model.Project, error) {
+	var project model.Project
+	var contextData string
+	var flagStateData string
+
+	row := s.database.QueryRowContext(ctx, `
+        SELECT key, source_environment_key, client_side_id, context, last_sync_time, flag_state 
+        FROM projects 
+        WHERE client_side_id = ? AND client_side_id IS NOT NULL
+    `, clientSideId)
+
+	if err := row.Scan(&project.Key, &project.SourceEnvironmentKey, &project.ClientSideId, &contextData, &project.LastSyncTime, &flagStateData); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, model.NewErrNotFound("project", clientSideId)
+		}
+		return nil, err
+	}
+
+	// Parse the context JSON string
+	if err := json.Unmarshal([]byte(contextData), &project.Context); err != nil {
+		return nil, errors.Wrap(err, "unable to unmarshal context data")
+	}
+
+	// Parse the flag state JSON string
+	if err := json.Unmarshal([]byte(flagStateData), &project.AllFlagsState); err != nil {
+		return nil, errors.Wrap(err, "unable to unmarshal flag state data")
+	}
+
+	return &project, nil
+}
+
 func (s *Sqlite) UpdateProject(ctx context.Context, project model.Project) (bool, error) {
 	flagsStateJson, err := json.Marshal(project.AllFlagsState)
 	if err != nil {
@@ -89,9 +121,9 @@ func (s *Sqlite) UpdateProject(ctx context.Context, project model.Project) (bool
 	}()
 	result, err := tx.ExecContext(ctx, `
 		UPDATE projects
-		SET flag_state = ?, last_sync_time = ?, context=?, source_environment_key=?
+		SET flag_state = ?, last_sync_time = ?, context=?, source_environment_key=?, client_side_id=?
 		WHERE key = ?;
-	`, flagsStateJson, project.LastSyncTime, project.Context.JSONString(), project.SourceEnvironmentKey, project.Key)
+	`, flagsStateJson, project.LastSyncTime, project.Context.JSONString(), project.SourceEnvironmentKey, project.ClientSideId, project.Key)
 	if err != nil {
 		return false, errors.Wrap(err, "unable to execute update project")
 	}
@@ -200,11 +232,12 @@ SELECT 1 FROM projects WHERE key = ?
 		return
 	}
 	_, err = tx.Exec(`
-INSERT INTO projects (key, source_environment_key, context, last_sync_time, flag_state)
-VALUES (?, ?, ?, ?, ?)
+INSERT INTO projects (key, source_environment_key, client_side_id, context, last_sync_time, flag_state)
+VALUES (?, ?, ?, ?, ?, ?)
 `,
 		project.Key,
 		project.SourceEnvironmentKey,
+		project.ClientSideId,
 		project.Context.JSONString(),
 		project.LastSyncTime,
 		string(flagsStateJson),
@@ -429,6 +462,11 @@ var validationQueries = []string{
 	"SELECT COUNT(1) from available_variations",
 }
 
+func isColumnExistsError(err error) bool {
+	return err != nil && (strings.Contains(err.Error(), "duplicate column name: client_side_id") ||
+		strings.Contains(err.Error(), "table projects has no column named client_side_id"))
+}
+
 func (s *Sqlite) runMigrations(ctx context.Context) error {
 	tx, err := s.database.BeginTx(ctx, nil)
 	if err != nil {
@@ -443,6 +481,7 @@ func (s *Sqlite) runMigrations(ctx context.Context) error {
 	CREATE TABLE IF NOT EXISTS projects (
 		key text PRIMARY KEY,
 		source_environment_key text NOT NULL,
+		client_side_id text,
 		context text NOT NULL,
 		last_sync_time timestamp NOT NULL,
 		flag_state TEXT NOT NULL
@@ -479,5 +518,14 @@ func (s *Sqlite) runMigrations(ctx context.Context) error {
 		return err
 	}
 
+	// Add client_side_id column to existing projects table if it doesn't exist
+	_, err = tx.Exec(`ALTER TABLE projects ADD COLUMN client_side_id text`)
+	if err != nil {
+		// Ignore error if column already exists
+		if !isColumnExistsError(err) {
+			return err
+		}
+	}
+
 	return tx.Commit()
 }

internal/dev_server/model/mocks/store.go

@@ -14,6 +14,7 @@ import (
 type Project struct {
 	Key                  string
 	SourceEnvironmentKey string
+	ClientSideId         *string
 	Context              ldcontext.Context
 	LastSyncTime         time.Time
 	AllFlagsState        FlagsState
@@ -57,6 +58,14 @@ func (project *Project) refreshExternalState(ctx context.Context) error {
 		return err
 	}
 	project.AvailableVariations = availableVariations
+
+	// Fetch client-side ID for caching
+	clientSideId, err := project.fetchClientSideId(ctx)
+	if err != nil {
+		return err
+	}
+	project.ClientSideId = clientSideId
+
 	return nil
 }
 
@@ -156,3 +165,19 @@ func (project Project) fetchFlagState(ctx context.Context) (FlagsState, error) {
 	flagsState = FromAllFlags(sdkFlags)
 	return flagsState, nil
 }
+
+func (project Project) fetchClientSideId(ctx context.Context) (*string, error) {
+	apiAdapter := adapters.GetApi(ctx)
+	environments, err := apiAdapter.GetProjectEnvironments(ctx, project.Key, "", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, env := range environments {
+		if env.Key == project.SourceEnvironmentKey {
+			return &env.Id, nil
+		}
+	}
+
+	return nil, errors.New("client-side ID not found for environment " + project.SourceEnvironmentKey)
+}

internal/dev_server/model/project.go

@@ -21,6 +21,8 @@ type Store interface {
 	GetDevProjectKeys(ctx context.Context) ([]string, error)
 	// GetDevProject fetches the project based on the projectKey. If it doesn't exist, ErrNotFound is returned
 	GetDevProject(ctx context.Context, projectKey string) (*Project, error)
+	// GetDevProjectByClientSideId fetches the project based on the client-side ID. If it doesn't exist, ErrNotFound is returned
+	GetDevProjectByClientSideId(ctx context.Context, clientSideId string) (*Project, error)
 	UpdateProject(ctx context.Context, project Project) (bool, error)
 	DeleteDevProject(ctx context.Context, projectKey string) (bool, error)
 	// InsertProject inserts the project. If it already exists, ErrAlreadyExists is returned

internal/dev_server/model/store.go

@@ -10,6 +10,10 @@ func CorsHeaders(handler http.Handler) http.Handler {
 		writer.Header().Set("Access-Control-Allow-Headers", "Cache-Control,Content-Type,Content-Length,Accept-Encoding,X-LaunchDarkly-User-Agent,X-LaunchDarkly-Payload-ID,X-LaunchDarkly-Wrapper,X-LaunchDarkly-Event-Schema,X-LaunchDarkly-Tags")
 		writer.Header().Set("Access-Control-Expose-Headers", "Date")
 		writer.Header().Set("Access-Control-Max-Age", "300")
+		if request.Method == http.MethodOptions {
+			writer.WriteHeader(http.StatusOK)
+			return
+		}
 		handler.ServeHTTP(writer, request)
 	})
 }

internal/dev_server/sdk/cors.go

@@ -13,6 +13,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 
+	ldapi "github.com/launchdarkly/api-client-go/v14"
 	"github.com/launchdarkly/go-sdk-common/v3/ldcontext"
 	"github.com/launchdarkly/go-sdk-common/v3/ldvalue"
 	ldclient "github.com/launchdarkly/go-server-sdk/v7"
@@ -49,6 +50,14 @@ func TestSDKRoutesViaGoSDK(t *testing.T) {
 	api.EXPECT().GetAllFlags(gomock.Any(), projectKey).
 		Return(nil, nil). // Available variations are not used for evaluation
 		AnyTimes()
+	api.EXPECT().GetProjectEnvironments(gomock.Any(), projectKey, "", nil).
+		Return([]ldapi.Environment{
+			{
+				Key: environmentKey,
+				Id:  "test-client-side-id",
+			},
+		}, nil).
+		AnyTimes()
 
 	// Wire up sdk routes in test server
 	router := mux.NewRouter()

internal/dev_server/sdk/go_sdk_test.go

@@ -2,10 +2,13 @@ package sdk
 
 import (
 	"context"
+	"fmt"
+	"log"
 	"net/http"
 	"strings"
 
 	"github.com/gorilla/mux"
+	"github.com/launchdarkly/ldcli/internal/dev_server/model"
 )
 
 type ctxKey string
@@ -22,11 +25,14 @@ func GetProjectKeyFromContext(ctx context.Context) string {
 func GetProjectKeyFromEnvIdParameter(pathParameter string) func(handler http.Handler) http.Handler {
 	return func(handler http.Handler) http.Handler {
 		return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+			log.Printf("GetProjectKeyFromEnvIdParameter middleware called: %s %s", request.Method, request.URL.Path)
 			projectKey, ok := mux.Vars(request)[pathParameter]
 			if !ok {
+				log.Printf("project key not found in path for parameter: %s", pathParameter)
 				http.Error(writer, "project key not on path", http.StatusNotFound)
 				return
 			}
+			log.Printf("Extracted project key: %s", projectKey)
 			ctx := request.Context()
 			ctx = SetProjectKeyOnContext(ctx, projectKey)
 			request = request.WithContext(ctx)
@@ -49,3 +55,34 @@ func GetProjectKeyFromAuthorizationHeader(handler http.Handler) http.Handler {
 		handler.ServeHTTP(writer, request)
 	})
 }
+
+func GetProjectKeyFromClientSideId(pathParameter string) func(handler http.Handler) http.Handler {
+	return func(handler http.Handler) http.Handler {
+		return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+			log.Printf("GetProjectKeyFromClientSideId middleware called: %s %s", request.Method, request.URL.Path)
+			clientSideId, ok := mux.Vars(request)[pathParameter]
+			if !ok {
+				log.Printf("client-side ID not found in path for parameter: %s", pathParameter)
+				http.Error(writer, "client-side ID not on path", http.StatusNotFound)
+				return
+			}
+			log.Printf("Extracted client-side ID: %s", clientSideId)
+
+			ctx := request.Context()
+			store := model.StoreFromContext(ctx)
+
+			// Look up project by client-side ID (fast database lookup)
+			project, err := store.GetDevProjectByClientSideId(ctx, clientSideId)
+			if err != nil {
+				log.Printf("No project found for client-side ID %s: %v", clientSideId, err)
+				http.Error(writer, fmt.Sprintf("project not found for client-side ID %s", clientSideId), http.StatusNotFound)
+				return
+			}
+
+			log.Printf("Found project %s for client-side ID %s", project.Key, clientSideId)
+			ctx = SetProjectKeyOnContext(ctx, project.Key)
+			request = request.WithContext(ctx)
+			handler.ServeHTTP(writer, request)
+		})
+	}
+}

internal/dev_server/sdk/project_key_middleware.go

@@ -0,0 +1,72 @@
+package sdk
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gorilla/mux"
+	"github.com/launchdarkly/ldcli/internal/dev_server/model"
+	"github.com/launchdarkly/ldcli/internal/dev_server/model/mocks"
+	"github.com/stretchr/testify/assert"
+	"go.uber.org/mock/gomock"
+)
+
+func TestGetProjectKeyFromClientSideId(t *testing.T) {
+	mockController := gomock.NewController(t)
+	store := mocks.NewMockStore(mockController)
+
+	router := mux.NewRouter()
+	router.Use(model.StoreMiddleware(store))
+
+	// Create a test handler that will be wrapped by the middleware
+	testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		projectKey := GetProjectKeyFromContext(r.Context())
+		fmt.Fprint(w, projectKey)
+	})
+
+	// Test case: project is found
+	t.Run("when project is found for client-side ID", func(t *testing.T) {
+		clientSideId := "test-client-side-id"
+		expectedProjectKey := "my-project"
+
+		// Set up the mock to return a project
+		store.EXPECT().GetDevProjectByClientSideId(gomock.Any(), clientSideId).Return(&model.Project{
+			Key: expectedProjectKey,
+		}, nil)
+
+		req := httptest.NewRequest("GET", fmt.Sprintf("/sdk/evalx/%s/some/other/path", clientSideId), nil)
+		rec := httptest.NewRecorder()
+
+		// Create a subrouter with the middleware
+		subrouter := router.PathPrefix("/sdk/evalx/{envId}").Subrouter()
+		subrouter.Use(GetProjectKeyFromClientSideId("envId"))
+		subrouter.PathPrefix("/").Handler(testHandler)
+
+		router.ServeHTTP(rec, req)
+
+		assert.Equal(t, http.StatusOK, rec.Code)
+		assert.Equal(t, expectedProjectKey, rec.Body.String())
+	})
+
+	// Test case: project is not found
+	t.Run("when project is not found for client-side ID", func(t *testing.T) {
+		clientSideId := "not-found-id"
+
+		// Set up the mock to return a not found error
+		store.EXPECT().GetDevProjectByClientSideId(gomock.Any(), clientSideId).Return(nil, model.NewErrNotFound("project", clientSideId))
+
+		req := httptest.NewRequest("GET", fmt.Sprintf("/sdk/evalx/%s/some/other/path", clientSideId), nil)
+		rec := httptest.NewRecorder()
+
+		// Create a subrouter with the middleware
+		subrouter := router.PathPrefix("/sdk/evalx/{envId}").Subrouter()
+		subrouter.Use(GetProjectKeyFromClientSideId("envId"))
+		subrouter.PathPrefix("/").Handler(testHandler)
+
+		router.ServeHTTP(rec, req)
+
+		assert.Equal(t, http.StatusNotFound, rec.Code)
+	})
+}

internal/dev_server/sdk/project_key_middleware_test.go

@@ -35,20 +35,20 @@ func BindRoutes(router *mux.Router) {
 	evalRouter := router.PathPrefix("/eval").Subrouter()
 	evalRouter.Use(CorsHeaders)
 	evalRouter.Methods(http.MethodOptions).HandlerFunc(ConstantResponseHandler(http.StatusOK, ""))
-	evalRouter.Use(GetProjectKeyFromEnvIdParameter("envId"))
+	evalRouter.Use(GetProjectKeyFromClientSideId("envId"))
 	evalRouter.PathPrefix("/{envId}").
 		Methods(http.MethodGet, "REPORT").
 		HandlerFunc(StreamClientFlags)
 
 	goalsRouter := router.Path("/sdk/goals/{envId}").Subrouter()
 	goalsRouter.Use(CorsHeaders)
-	goalsRouter.Use(GetProjectKeyFromEnvIdParameter("envId"))
+	goalsRouter.Use(GetProjectKeyFromClientSideId("envId"))
 	goalsRouter.Methods(http.MethodOptions).HandlerFunc(ConstantResponseHandler(http.StatusOK, ""))
 	goalsRouter.Methods(http.MethodGet).HandlerFunc(ConstantResponseHandler(http.StatusOK, "[]"))
 
 	evalXRouter := router.PathPrefix("/sdk/evalx/{envId}").Subrouter()
 	evalXRouter.Use(CorsHeaders)
-	evalXRouter.Use(GetProjectKeyFromEnvIdParameter("envId"))
+	evalXRouter.Use(GetProjectKeyFromClientSideId("envId"))
 	evalXRouter.Methods(http.MethodOptions).HandlerFunc(ConstantResponseHandler(http.StatusOK, ""))
-	evalXRouter.Methods(http.MethodGet, "REPORT").HandlerFunc(GetClientFlags)
+	evalXRouter.PathPrefix("/").Methods(http.MethodGet, "REPORT").HandlerFunc(GetClientFlags)
 }