Add LLM capabilities to search through all databases

core/graph/schema.graphqls

@@ -3,6 +3,7 @@
 # https://gqlgen.com/getting-started/
 
 enum DatabaseType {
+  All,
   Postgres,
   MySQL,
   Sqlite3,

core/src/auth/auth.go

@@ -17,6 +17,7 @@ type AuthKey string
 
 const (
 	AuthKey_Token       AuthKey = "Token"
+	AuthKey_Profiles    AuthKey = "Profiles"
 	AuthKey_Credentials AuthKey = "Credentials"
 )
 
@@ -28,6 +29,14 @@ func GetCredentials(ctx context.Context) *engine.Credentials {
 	return credentials.(*engine.Credentials)
 }
 
+func GetProfiles(ctx context.Context) []*engine.Credentials {
+	profiles := ctx.Value(AuthKey_Profiles)
+	if profiles == nil {
+		return nil
+	}
+	return profiles.([]*engine.Credentials)
+}
+
 func isPublicRoute(r *http.Request) bool {
 	return !strings.HasPrefix(r.URL.Path, "/api/") && r.URL.Path != "/api"
 }
@@ -70,6 +79,22 @@ func AuthMiddleware(next http.Handler) http.Handler {
 			return
 		}
 
+		allProfiles := []*engine.Credentials{}
+		profileCookie, err := r.Cookie(string(AuthKey_Profiles))
+		if err == nil {
+			decodedValue, err := base64.StdEncoding.DecodeString(profileCookie.Value)
+			if err != nil {
+				w.WriteHeader(http.StatusUnauthorized)
+				return
+			}
+
+			err = json.Unmarshal(decodedValue, &allProfiles)
+			if err != nil {
+				w.WriteHeader(http.StatusBadRequest)
+				return
+			}
+		}
+
 		if credentials.Id != nil {
 			profiles := src.GetLoginProfiles()
 			for i, loginProfile := range profiles {
@@ -87,6 +112,7 @@ func AuthMiddleware(next http.Handler) http.Handler {
 
 		ctx := r.Context()
 		ctx = context.WithValue(ctx, AuthKey_Credentials, credentials)
+		ctx = context.WithValue(ctx, AuthKey_Profiles, allProfiles)
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})
 }

core/src/auth/login.go

@@ -17,19 +17,66 @@ func Login(ctx context.Context, input *model.LoginCredentials) (*model.StatusRes
 		return nil, err
 	}
 
-	cookieValue := base64.StdEncoding.EncodeToString(loginInfoJSON)
+	tokenValue := base64.StdEncoding.EncodeToString(loginInfoJSON)
 
-	cookie := &http.Cookie{
+	tokenCookie := &http.Cookie{
 		Name:     string(AuthKey_Token),
-		Value:    cookieValue,
+		Value:    tokenValue,
 		Path:     "/",
 		HttpOnly: true,
 		Expires:  time.Now().Add(24 * time.Hour),
 	}
+	http.SetCookie(ctx.Value(common.RouterKey_ResponseWriter).(http.ResponseWriter), tokenCookie)
 
-	http.SetCookie(ctx.Value(common.RouterKey_ResponseWriter).(http.ResponseWriter), cookie)
+	var profiles []model.LoginCredentials
+	profilesCookie, err := ctx.Value(common.RouterKey_Request).(*http.Request).Cookie(string(AuthKey_Profiles))
+	if err == nil {
+		decodedProfiles, err := base64.StdEncoding.DecodeString(profilesCookie.Value)
+		if err == nil {
+			json.Unmarshal(decodedProfiles, &profiles)
+		}
+	}
+
+	profiles = append(profiles, *input)
+
+	profiles = removeDuplicateProfiles(profiles)
+
+	profilesJSON, err := json.Marshal(profiles)
+	if err != nil {
+		return nil, err
+	}
+
+	profilesValue := base64.StdEncoding.EncodeToString(profilesJSON)
+
+	profilesCookie = &http.Cookie{
+		Name:     string(AuthKey_Profiles),
+		Value:    profilesValue,
+		Path:     "/",
+		HttpOnly: true,
+		Expires:  time.Now().Add(24 * time.Hour),
+	}
+	http.SetCookie(ctx.Value(common.RouterKey_ResponseWriter).(http.ResponseWriter), profilesCookie)
 
 	return &model.StatusResponse{
 		Status: true,
 	}, nil
 }
+
+func removeDuplicateProfiles(profiles []model.LoginCredentials) []model.LoginCredentials {
+	uniqueProfiles := make([]model.LoginCredentials, 0)
+	profileMap := make(map[string]bool)
+
+	for _, profile := range profiles {
+		key := generateProfileKey(profile)
+		if !profileMap[key] {
+			uniqueProfiles = append(uniqueProfiles, profile)
+			profileMap[key] = true
+		}
+	}
+
+	return uniqueProfiles
+}
+
+func generateProfileKey(profile model.LoginCredentials) string {
+	return profile.Type + profile.Hostname + profile.Username + profile.Database
+}

core/src/common/context.go

@@ -4,4 +4,5 @@ type RouterKey string
 
 const (
 	RouterKey_ResponseWriter RouterKey = "ResponseWriter"
+	RouterKey_Request        RouterKey = "Request"
 )

core/src/common/utils.go

@@ -75,3 +75,11 @@ func JoinWithQuotes(arr []string) string {
 
 	return strings.Join(quotedStrings, ", ")
 }
+
+func MapArrayPtr[T any, V any](items []*T, mapFunc func(*T) *V) []*V {
+	mappedItems := []*V{}
+	for _, item := range items {
+		mappedItems = append(mappedItems, mapFunc(item))
+	}
+	return mappedItems
+}

core/src/engine/engine.go

@@ -1,6 +1,10 @@
 package engine
 
-import "github.com/clidey/whodb/core/graph/model"
+import (
+	"fmt"
+
+	"github.com/clidey/whodb/core/graph/model"
+)
 
 type DatabaseType string
 
@@ -34,6 +38,27 @@ func (e *Engine) Choose(databaseType DatabaseType) *Plugin {
 	return nil
 }
 
+func (e *Engine) Chat(configs []*PluginConfig) ([]*ChatMessage, error) {
+	for _, config := range configs {
+		plugin := e.Choose(config.Credentials.Type)
+		schemas, err := plugin.GetSchema(config)
+		if err != nil {
+			return nil, err
+		}
+		for _, schema := range schemas {
+			storageUnits, err := plugin.GetStorageUnits(config, schema)
+			if err != nil {
+				return nil, err
+			}
+			for _, storageUnit := range storageUnits {
+				// use this to actually create the query
+				fmt.Sprintf("%v", storageUnit.Name)
+			}
+		}
+	}
+	return []*ChatMessage{}, nil
+}
+
 func GetStorageUnitModel(unit StorageUnit) *model.StorageUnit {
 	attributes := []*model.Record{}
 	for _, attribute := range unit.Attributes {

core/src/engine/plugin.go

@@ -2,6 +2,7 @@ package engine
 
 type Credentials struct {
 	Id       *string
+	Type     DatabaseType
 	Hostname string
 	Username string
 	Password string

core/src/router/middleware.go

@@ -10,6 +10,7 @@ import (
 func contextMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		ctx := context.WithValue(r.Context(), common.RouterKey_ResponseWriter, w)
+		ctx = context.WithValue(ctx, common.RouterKey_Request, r)
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})
 }

frontend/src/generated/graphql.tsx

@@ -37,6 +37,7 @@ export type Column = {
 };
 
 export enum DatabaseType {
+  All = 'All',
   ElasticSearch = 'ElasticSearch',
   MariaDb = 'MariaDB',
   MongoDb = 'MongoDB',