refactor(ui): stop using /meta/config endpoint

cmd/flipt/main.go

@@ -324,18 +324,12 @@
 		logger.Debug("local state directory exists", zap.String("path", cfg.Meta.StateDirectory))
 	}
 
-	info := info.Flipt{
-		Commit:           commit,
-		BuildDate:        date,
-		GoVersion:        goVersion,
-		Version:          version,
-		LatestVersion:    releaseInfo.LatestVersion,
-		LatestVersionURL: releaseInfo.LatestVersionURL,
-		IsRelease:        isRelease,
-		UpdateAvailable:  releaseInfo.UpdateAvailable,
-		OS:               goOS,
-		Arch:             goArch,
-	}
+	info := info.New(
+		info.WithBuild(commit, date, goVersion, version, isRelease),
+		info.WithLatestRelease(releaseInfo),
+		info.WithOS(goOS, goArch),
+		info.WithConfig(cfg),
+	)
 
 	if cfg.Meta.TelemetryEnabled {
 		logger := logger.With(zap.String("component", "telemetry"))

internal/config/storage.go

@@ -45,6 +45,16 @@ type StorageConfig struct {
 	ReadOnly *bool                `json:"readOnly,omitempty" mapstructure:"read_only,omitempty" yaml:"read_only,omitempty"`
 }
 
+func (c *StorageConfig) Info() map[string]string {
+	if c.Type == GitStorageType {
+		return map[string]string{
+			"repository": c.Git.Repository,
+			"ref":        c.Git.Ref,
+		}
+	}
+	return nil
+}
+
 func (c *StorageConfig) setDefaults(v *viper.Viper) error {
 	switch v.GetString("storage.type") {
 	case string(LocalStorageType):

internal/config/storage_test.go

@@ -0,0 +1,25 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStorageConfigInfo(t *testing.T) {
+	tests := []struct {
+		config   StorageConfig
+		expected map[string]string
+	}{
+		{StorageConfig{Type: DatabaseStorageType}, nil},
+		{StorageConfig{Type: GitStorageType, Git: &StorageGitConfig{Repository: "repo1", Ref: "v1.0.0"}}, map[string]string{
+			"ref": "v1.0.0", "repository": "repo1",
+		}},
+	}
+
+	for _, tt := range tests {
+		t.Run(string(tt.config.Type), func(t *testing.T) {
+			assert.Equal(t, tt.expected, tt.config.Info())
+		})
+	}
+}

internal/info/flipt.go

@@ -3,19 +3,88 @@ package info
 import (
 	"encoding/json"
 	"net/http"
+
+	"go.flipt.io/flipt/internal/config"
+	"go.flipt.io/flipt/internal/release"
 )
 
+func New(opts ...Option) Flipt {
+	f := Flipt{}
+	for _, opt := range opts {
+		opt(&f)
+	}
+	return f
+}
+
+func WithBuild(commit, date, goVersion, version string, isRelease bool) Option {
+	return func(f *Flipt) {
+		f.Commit = commit
+		f.BuildDate = date
+		f.GoVersion = goVersion
+		f.IsRelease = isRelease
+		f.Version = version
+	}
+}
+
+func WithLatestRelease(releaseInfo release.Info) Option {
+	return func(f *Flipt) {
+		f.LatestVersion = releaseInfo.LatestVersion
+		f.LatestVersionURL = releaseInfo.LatestVersionURL
+		f.UpdateAvailable = releaseInfo.UpdateAvailable
+	}
+}
+
+func WithOS(os, arch string) Option {
+	return func(f *Flipt) {
+		f.OS = os
+		f.Arch = arch
+	}
+}
+
+func WithConfig(cfg *config.Config) Option {
+	return func(f *Flipt) {
+		f.Authentication = authentication{Required: cfg.Authentication.Required}
+		f.Storage = storage{Type: cfg.Storage.Type, Metadata: cfg.Storage.Info()}
+		f.Analytics = &analytics{Enabled: cfg.Analytics.Enabled()}
+		f.UI = &ui{Theme: cfg.UI.DefaultTheme, TopbarColor: cfg.UI.Topbar.Color}
+	}
+}
+
+type Option func(f *Flipt)
+
+type authentication struct {
+	Required bool `json:"required"`
+}
+
+type analytics struct {
+	Enabled bool `json:"enabled,omitempty"`
+}
+
+type storage struct {
+	Type     config.StorageType `json:"type"`
+	Metadata map[string]string  `json:"metadata,omitempty"`
+}
+
+type ui struct {
+	Theme       config.UITheme `json:"theme,omitempty"`
+	TopbarColor string         `json:"topbarColor,omitempty"`
+}
+
 type Flipt struct {
-	Version          string `json:"version,omitempty"`
-	LatestVersion    string `json:"latestVersion,omitempty"`
-	LatestVersionURL string `json:"latestVersionURL,omitempty"`
-	Commit           string `json:"commit,omitempty"`
-	BuildDate        string `json:"buildDate,omitempty"`
-	GoVersion        string `json:"goVersion,omitempty"`
-	UpdateAvailable  bool   `json:"updateAvailable"`
-	IsRelease        bool   `json:"isRelease"`
-	OS               string `json:"os,omitempty"`
-	Arch             string `json:"arch,omitempty"`
+	Version          string         `json:"version,omitempty"`
+	LatestVersion    string         `json:"latestVersion,omitempty"`
+	LatestVersionURL string         `json:"latestVersionURL,omitempty"`
+	Commit           string         `json:"commit,omitempty"`
+	BuildDate        string         `json:"buildDate,omitempty"`
+	GoVersion        string         `json:"goVersion,omitempty"`
+	UpdateAvailable  bool           `json:"updateAvailable"`
+	IsRelease        bool           `json:"isRelease"`
+	OS               string         `json:"os,omitempty"`
+	Arch             string         `json:"arch,omitempty"`
+	Authentication   authentication `json:"authentication"`
+	Storage          storage        `json:"storage"`
+	Analytics        *analytics     `json:"analytics,omitempty"`
+	UI               *ui            `json:"ui,omitempty"`
 }
 
 func (f Flipt) IsDevelopment() bool {

internal/info/flipt_test.go

@@ -0,0 +1,44 @@
+package info
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.flipt.io/flipt/internal/config"
+	"go.flipt.io/flipt/internal/release"
+)
+
+func TestNew(t *testing.T) {
+	f := New(
+		WithOS("linux", "amd64"),
+		WithBuild("commit", "date", "goVersion", "version", true),
+		WithLatestRelease(release.Info{LatestVersion: "latestVersion", LatestVersionURL: "latestVersionURL", UpdateAvailable: true}),
+		WithConfig(config.Default()),
+	)
+
+	assert.Equal(t, "commit", f.Commit)
+	assert.Equal(t, "date", f.BuildDate)
+	assert.Equal(t, "goVersion", f.GoVersion)
+	assert.Equal(t, "version", f.Version)
+	assert.True(t, f.IsRelease)
+	assert.Equal(t, "latestVersion", f.LatestVersion)
+	assert.Equal(t, "latestVersionURL", f.LatestVersionURL)
+	assert.True(t, f.UpdateAvailable)
+	assert.Equal(t, "linux", f.OS)
+	assert.Equal(t, "amd64", f.Arch)
+	assert.False(t, f.Authentication.Required)
+	assert.False(t, f.Analytics.Enabled)
+	assert.Equal(t, config.DatabaseStorageType, f.Storage.Type)
+}
+
+func TestHttpHandler(t *testing.T) {
+	f := New()
+	f.Storage.Type = config.DatabaseStorageType
+	r := httptest.NewRequest("GET", "/info", nil)
+	w := httptest.NewRecorder()
+	f.ServeHTTP(w, r)
+	assert.Equal(t, http.StatusOK, w.Code)
+	assert.Equal(t, `{"updateAvailable":false,"isRelease":false,"authentication":{"required":false},"storage":{"type":"database"}}`, w.Body.String())
+}

ui/src/app/Layout.tsx

@@ -17,11 +17,7 @@ import Sidebar from '~/components/Sidebar';
 import { useSession } from '~/data/hooks/session';
 import { useAppDispatch } from '~/data/hooks/store';
 import { LoadingStatus } from '~/types/Meta';
-import {
-  fetchConfigAsync,
-  fetchInfoAsync,
-  selectConfig
-} from './meta/metaSlice';
+import { fetchInfoAsync, selectConfig } from './meta/metaSlice';
 import {
   currentNamespaceChanged,
   selectCurrentNamespace,
@@ -62,7 +58,6 @@ function InnerLayout() {
 
   useEffect(() => {
     dispatch(fetchInfoAsync());
-    dispatch(fetchConfigAsync());
   }, [dispatch]);
 
   if (!session) {

ui/src/app/meta/metaSlice.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { createAsyncThunk, createSlice } from '@reduxjs/toolkit';
-import { getConfig, getInfo } from '~/data/api';
+import { getInfo } from '~/data/api';
 import { IConfig, IInfo, LoadingStatus, StorageType } from '~/types/Meta';
 import { Theme } from '~/types/Preferences';
 
@@ -40,23 +40,27 @@ export const metaSlice = createSlice({
   reducers: {},
   extraReducers(builder) {
     builder
-      .addCase(fetchInfoAsync.fulfilled, (state, action) => {
-        state.info = action.payload;
-      })
-      .addCase(fetchConfigAsync.pending, (state, _action) => {
+      .addCase(fetchInfoAsync.pending, (state, _action) => {
         state.config.status = LoadingStatus.LOADING;
       })
-      .addCase(fetchConfigAsync.fulfilled, (state, action) => {
-        state.config = action.payload;
+      .addCase(fetchInfoAsync.fulfilled, (state, action) => {
+        state.info = action.payload;
         state.config.status = LoadingStatus.SUCCEEDED;
         state.config.analyticsEnabled =
-          action.payload.analytics.storage.clickhouse?.enabled ||
-          action.payload.analytics.storage.prometheus?.enabled;
-        if (action.payload.storage?.readOnly === undefined) {
+          action.payload.analytics?.enabled || false;
+        if (action.payload.storage !== undefined) {
+          state.config.storage.type = action.payload.storage?.type;
+          state.config.storage.git = action.payload.storage?.metadata;
           state.config.storage.readOnly =
-            action.payload.storage?.type &&
-            action.payload.storage?.type !== StorageType.DATABASE;
+            action.payload.storage &&
+            action.payload.storage.type !== StorageType.DATABASE;
         }
+        state.config.ui = {
+          defaultTheme: action.payload.ui?.Theme || Theme.SYSTEM,
+          topbar: {
+            color: action.payload.ui?.TopbarColor || ''
+          }
+        };
       });
   }
 });
@@ -71,12 +75,4 @@ export const fetchInfoAsync = createAsyncThunk('meta/fetchInfo', async () => {
   return response;
 });
 
-export const fetchConfigAsync = createAsyncThunk(
-  'meta/fetchConfig',
-  async () => {
-    const response = await getConfig();
-    return response;
-  }
-);
-
 export default metaSlice.reducer;

ui/src/app/preferences/preferencesSlice.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-use-before-define */
 import { createSlice } from '@reduxjs/toolkit';
-import { fetchConfigAsync } from '~/app/meta/metaSlice';
 import { RootState } from '~/store';
 import { Theme, Timezone } from '~/types/Preferences';
+import { fetchInfoAsync } from '~/app/meta/metaSlice';
 
 export const preferencesKey = 'preferences';
 
@@ -28,14 +28,14 @@ export const preferencesSlice = createSlice({
     }
   },
   extraReducers(builder) {
-    builder.addCase(fetchConfigAsync.fulfilled, (state, action) => {
+    builder.addCase(fetchInfoAsync.fulfilled, (state, action) => {
       const currentPreference = JSON.parse(
         localStorage.getItem(preferencesKey) || '{}'
       ) as IPreferencesState;
 
       // If there isn't currently a set theme, set to the default theme
       if (!currentPreference.theme) {
-        state.theme = action.payload.ui.defaultTheme;
+        state.theme = action.payload.uiTheme;
       }
 
       if (!currentPreference.timezone) {

ui/src/components/SessionProvider.tsx

@@ -1,5 +1,5 @@
 import { createContext, useEffect, useMemo } from 'react';
-import { getAuthSelf, getConfig, getInfo } from '~/data/api';
+import { getAuthSelf, getInfo } from '~/data/api';
 import { useLocalStorage } from '~/data/hooks/storage';
 import { IAuthGithubInternal } from '~/types/auth/Github';
 import { IAuthJWTInternal } from '~/types/auth/JWT';
@@ -27,16 +27,16 @@ export default function SessionProvider({
   const [session, setSession, clearSession] = useLocalStorage('session', null);
 
   useEffect(() => {
-    const clearSessionIfNecessary = async () => {
-      const config = await getConfig();
-      if (session && session.required !== config.authentication.required) {
+    const clearSessionIfNecessary = async (required: boolean) => {
+      if (session && session.required !== required) {
         clearSession();
       }
     };
 
     const loadSession = async () => {
+      let info: any = null;
       try {
-        await getInfo();
+        info = await getInfo();
       } catch (err) {
         // if we can't get the info, we're not logged in
         // or there was an error, either way, clear the session so we redirect
@@ -45,8 +45,8 @@ export default function SessionProvider({
         return;
       }
 
-      if (session) {
-        clearSessionIfNecessary();
+      if (session && info) {
+        clearSessionIfNecessary(info.authentication?.required);
         if (session) {
           return;
         }

ui/src/data/api.ts

@@ -191,7 +191,3 @@ async function getMeta(path: string) {
 export async function getInfo() {
   return getMeta('/info');
 }
-
-export async function getConfig() {
-  return getMeta('/config');
-}

ui/tests/flags.spec.ts

@@ -135,10 +135,10 @@ test.describe('Flags', () => {
 
 test.describe('Flags - Read Only', () => {
   test.beforeEach(async ({ page }) => {
-    await page.route(/\/meta\/config/, async (route) => {
+    await page.route(/\/meta\/info/, async (route) => {
       const response = await route.fetch();
       const json = await response.json();
-      json.storage = { type: 'git' };
+      json.storage.type = 'git';
       // Fulfill using the original response, while patching the
       // response body with our changes to mock git storage for read only mode
       await route.fulfill({ response, json });

ui/tests/index.spec.ts

@@ -11,10 +11,10 @@ test.describe('Root', () => {
 
 test.describe('Root - Read Only', () => {
   test.beforeEach(async ({ page }) => {
-    await page.route(/\/meta\/config/, async (route) => {
+    await page.route(/\/meta\/info/, async (route) => {
       const response = await route.fetch();
       const json = await response.json();
-      json.storage = { type: 'git' };
+      json.storage.type = 'git';
       // Fulfill using the original response, while patching the
       // response body with our changes to mock git storage for read only mode
       await route.fulfill({ response, json });