implement web functionality

Author: mmaelicke

internal/api/server.go

@@ -0,0 +1,78 @@
+package ollama
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/urfave/cli/v2"
+)
+
+func getOllamaRest(url string) ([]byte, error) {
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get %s: %w", url, err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	return body, nil
+}
+
+type ollamaTags struct {
+	Models []ollamaTag `json:"models"`
+}
+
+type ollamaTag struct {
+	Model string `json:"model"`
+	Name  string `json:"name"`
+}
+
+func OllamaConnectionFromContext(c *cli.Context) error {
+	// get the connection string
+	connectionString := c.String("ollama-url")
+	if connectionString == "" {
+		return fmt.Errorf("ollama-url is required")
+	}
+
+	// make sure the response body is 'Ollama is running'
+	body, err := getOllamaRest(connectionString)
+	if err != nil {
+		return fmt.Errorf("failed to get the response from %s: %w", connectionString, err)
+	}
+	if string(body) != "Ollama is running" {
+		return fmt.Errorf("something was at %s, but it seems like it was not Ollama: %v", connectionString, body)
+	}
+
+	// check that a model of type nomic-embed-text is available
+	body, err = getOllamaRest(connectionString + "/api/tags")
+	if err != nil {
+		return fmt.Errorf("failed to get tags from %s: %w", connectionString, err)
+	}
+
+	var tags ollamaTags
+	if err := json.Unmarshal(body, &tags); err != nil {
+		return fmt.Errorf("failed to read the existing models from ollama: %w", err)
+	}
+
+	// for now we hardcode nomic-embed-text
+	var foundTag ollamaTag
+	for _, tag := range tags.Models {
+		if strings.HasPrefix(tag.Model, "nomic-embed-text") {
+			foundTag = tag
+			break
+		}
+	}
+	if foundTag == (ollamaTag{}) {
+		return fmt.Errorf("datailama needs the nomic-embed-text model, which was not found Run \n ollama pull nomic-embed-text:latest\n to get it")
+	} else {
+		fmt.Printf("found %v\n", foundTag.Name)
+	}
+	return nil
+}

internal/ollama/ollama.go

@@ -7,36 +7,68 @@ import (
 
 	"github.com/hydrocode-de/datailama/internal/db"
 	"github.com/hydrocode-de/datailama/internal/sql"
+	"github.com/hydrocode-de/datailama/internal/version"
 )
 
+// VersionOutput defines the response structure for the version endpoint
+type VersionOutput struct {
+	Body struct {
+		Version   string `json:"version" example:"1.0.0" doc:"The version of the application"`
+		BuildTime string `json:"build_time,omitempty" doc:"The build time of the application"`
+		GitCommit string `json:"git_commit,omitempty" doc:"The git commit of the application"`
+	}
+}
+
+// TitleSearchOutput defines the response structure for the paper search endpoint
 type TitleSearchOutput struct {
 	Body struct {
 		Count int                         `json:"count"`
 		Paper []sql.SearchPaperByTitleRow `json:"paper"`
 	}
 }
 
+// getVersion handles the version endpoint
+func getVersion(ctx context.Context, input *struct{}) (*VersionOutput, error) {
+	resp := &VersionOutput{}
+	resp.Body.Version = version.Version
+	resp.Body.BuildTime = version.BuildTime
+	resp.Body.GitCommit = version.GitCommit
+	return resp, nil
+}
+
+// searchByTitle handles the paper search endpoint
 func searchByTitle(ctx context.Context, input *struct {
 	Title     string `query:"title,omitempty" doc:"The title to search for"`
 	Author    string `query:"author,omitempty" doc:"The author to limit the search to"`
 	OrderBy   string `query:"order,omitempty" example:"citations_year" doc:"The property to order the results by. Can be citations_year or citations"`
 	Direction string `query:"direction,omitempty" example:"desc" doc:"The direction to order the results by. Can be asc or desc"`
 }) (*TitleSearchOutput, error) {
-	if strings.ToLower(input.OrderBy) != "citations_year" && strings.ToLower(input.OrderBy) != "citations" {
+	if strings.ToLower(input.OrderBy) != "citations_year" && strings.ToLower(input.OrderBy) != "citations" && input.OrderBy != "" {
 		return nil, fmt.Errorf("invalid order by argument: %v. Has to be citations_year or citations", input.OrderBy)
 	}
 
-	if strings.ToLower(input.Direction) != "asc" && strings.ToLower(input.Direction) != "desc" {
+	if strings.ToLower(input.Direction) != "asc" && strings.ToLower(input.Direction) != "desc" && input.Direction != "" {
 		return nil, fmt.Errorf("invalid direction argument: %v. Has to be asc or desc", input.Direction)
 	}
 
+	// Set defaults
+	orderBy := input.OrderBy
+	if orderBy == "" {
+		orderBy = "citations_year"
+	}
+
+	direction := input.Direction
+	if direction == "" {
+		direction = "desc"
+	}
+
 	db := ctx.Value("db").(*db.Manager)
 
 	papers, err := db.SearchPaperByTitle(ctx, sql.SearchPaperByTitleParams{
 		Title:     input.Title,
 		Author:    input.Author,
-		OrderBy:   input.OrderBy,
-		Direction: input.Direction,
+		OrderBy:   orderBy,
+		Direction: direction,
 		Limit:     15,
 	})
 	if err != nil {

internal/api/paper.go internal/web/api/handlers.gointernal/api/paper.go renamed to internal/web/api/handlers.go

@@ -0,0 +1,44 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/danielgtaylor/huma/v2"
+	"github.com/danielgtaylor/huma/v2/adapters/humago"
+	"github.com/hydrocode-de/datailama/internal/db"
+	"github.com/hydrocode-de/datailama/internal/version"
+)
+
+// RegisterRoutes sets up the API routes using Huma
+func RegisterRoutes(router *http.ServeMux, dbManager *db.Manager) {
+	// Create Huma API on a specific path prefix
+	api := humago.New(router, huma.DefaultConfig("DataILama API", version.Version))
+
+	// Register middleware
+	api.UseMiddleware(DbMiddleware(dbManager))
+
+	// Register API endpoints
+	huma.Register(api, huma.Operation{
+		OperationID: "getVersion",
+		Method:      http.MethodGet,
+		Path:        "/api/version",
+		Summary:     "Get the version",
+		Description: "Get the version of DataILama",
+	}, getVersion)
+
+	huma.Register(api, huma.Operation{
+		OperationID: "searchPaperByTitle",
+		Method:      http.MethodGet,
+		Path:        "/api/paper/search",
+		Summary:     "Search for Papers by Title",
+		Description: "Search by Title. Currently the search is a case insensive excact match to a part of the title.",
+	}, searchByTitle)
+}
+
+// DbMiddleware provides database access to API handlers
+func DbMiddleware(db *db.Manager) func(ctx huma.Context, next func(huma.Context)) {
+	return func(ctx huma.Context, next func(huma.Context)) {
+		newCtx := huma.WithValue(ctx, "db", db)
+		next(newCtx)
+	}
+}

internal/web/api/routes.go

@@ -0,0 +1,46 @@
+package web
+
+import (
+	"net/http"
+
+	"github.com/hydrocode-de/datailama/internal/db"
+	"github.com/hydrocode-de/datailama/internal/web/api"
+	"github.com/hydrocode-de/datailama/internal/web/site"
+)
+
+// Server combines both API and site functionality
+type Server struct {
+	DB     *db.Manager
+	Router *http.ServeMux
+}
+
+// NewServer creates a new server with both API and site routes
+func NewServer(dbManager *db.Manager, apiOnly bool) *Server {
+	// Create main router
+	router := http.NewServeMux()
+
+	server := &Server{
+		DB:     dbManager,
+		Router: router,
+	}
+
+	// Register API routes (using Huma)
+	api.RegisterRoutes(router, dbManager)
+
+	// Register frontend routes
+	if !apiOnly || true {
+		// also handle the exact path "/" to redirect to /app/ for now
+		router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+			http.Redirect(w, r, "/app/", http.StatusSeeOther)
+		})
+		//router.Handle("/app/", http.StripPrefix("/app/", http.FileServer(http.Dir("internal/web/site/frontend"))))
+		router.Handle("/app/", http.StripPrefix("/app/", http.FileServer(http.FS(site.GetEmbedFrontend()))))
+	}
+
+	return server
+}
+
+// ServeHTTP implements the http.Handler interface
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	s.Router.ServeHTTP(w, r)
+}

internal/web/server.go

@@ -0,0 +1,34 @@
+package site
+
+import (
+	"embed"
+	"io/fs"
+	"log"
+)
+
+// FrontendFS contains the embedded frontend build
+//
+//go:embed frontend/**/*
+//go:embed frontend/*
+var FrontendFS embed.FS
+
+func init() {
+	// Print all embedded files
+	fs.WalkDir(FrontendFS, ".", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if !d.IsDir() {
+			log.Printf("Embedded file: %s", path)
+		}
+		return nil
+	})
+}
+
+func GetEmbedFrontend() fs.FS {
+	frontendFS, err := fs.Sub(FrontendFS, "frontend")
+	if err != nil {
+		panic(err)
+	}
+	return frontendFS
+}