Change NewHandler to New and update README

Author: joelseq

README.md

@@ -2,19 +2,20 @@
 
 [![Build](https://github.com/joelseq/sqliteadmin-go/actions/workflows/build.yml/badge.svg)](https://github.com/joelseq/sqliteadmin-go/actions/workflows/build.yml)
 
-SQLite Admin provides a lightweight web server to interact with a SQLite database. It allows you to:
+SQLite Admin is a Golang library and binary which enables you to easily interact with a SQLite database. It allows you to:
 
 - Browse tables and their schemas.
 - View table data along with adding filters, limits and offsets.
 - Modify individual columns in existing rows.
 
-It can either by installed as a binary or embedded into an existing Golang backend as a library.
+![screenshot](assets/sqlite-admin-filtering.png)
+
+It can either be integrated into an existing Golang backend as a library or installed as a binary.
 
 The web server can be interacted with by going to https://sqliteadmin.dev.
 
 The source code for the web UI can be found at https://github.com/joelseq/sqliteadmin-ui
 
-
 ## Motivation
 
 SQLite is very easy to add as an embedded database but it's difficult to manage the database once it's deployed in an application.
@@ -23,7 +24,41 @@ Existing tools primarily focus on local SQLite files, requiring manual interacti
 
 The alternative is to use a cloud-hosted version like those provided by [Turso](https://turso.tech/) which enables interacting with the database using tools like [Drizzle Studio](https://orm.drizzle.team/drizzle-studio/overview). This adds complexity to the setup and deployment of your application and you lose out on the value of having an embedded database.
 
-This project fills that gap by providing an easy way to view and manage an embedded SQLite database via a web UI—no need to migrate to a cloud provider or use ad-hoc solutions.
+This project fills that gap by providing an easy way to view and manage an embedded SQLite database via a web UI — no need to migrate to a cloud provider or use ad-hoc solutions.
+
+## Using as a library
+
+```go
+config := sqliteadmin.Config{
+  DB: db,               // *sql.DB
+  Username: "username", // username to use to login from https://sqliteadmin.dev
+  Password: "password", // password to use to login from https://sqliteadmin.dev
+  Logger: logger,       // optional, implements the Logger interface
+}
+admin := sqliteadmin.New(config)
+
+// HandlePost is a HandlerFunc that you can pass in to your router
+router.Post("/admin", admin.HandlePost)
+```
+
+Check out the full code at `examples/chi/main.go`.
+
+You can also run the example to test out the admin UI:
+
+```bash
+go run examples/chi/main.go
+```
+
+This will spin up a server on `http://localhost:8080`. You can then interact with your local server by going to `https://sqliteadmin.dev` and passing in the following credentials:
+
+```
+username: user
+password: password
+endpoint: http://localhost:8080/admin
+```
+
+> [!NOTE]  
+> If you are seeing "An unexpected error occurred" when trying to connect, try disabling your adblock.
 
 ## Installing as a binary
 
@@ -38,13 +73,15 @@ go install github.com/joelseq/sqliteadmin-go/cmd/sqliteadmin@latest
 ```bash
 make build
 ```
+
 This will add the `sqliteadmin` binary to `/tmp/bin`
 
 ### Usage
 
 In order to add authentication, the following environment variables are required: `SQLITEADMIN_USERNAME`, `SQLITEADMIN_PASSWORD`.
 
 e.g.:
+
 ```bash
 export SQLITEADMIN_USERNAME=user
 export SQLITEADMIN_PASSWORD=password
@@ -58,27 +95,6 @@ sqliteadmin serve <path to sqlite db> -p 8080
 
 Your SQLite database can now be accessed by visiting https://sqliteadmin.dev and providing the credentials and endpoint (including port).
 
-## Using as a library
-
-Check out the `examples/` directory to see how to integrate it into an existing Golang backend.
-
-You can also run the examples to test out the admin UI:
-
-```bash
-go run examples/chi/main.go
-```
-
-This will spin up a server on `http://localhost:8080`. You can then interact with your local server by going to `https://sqliteadmin.dev` and passing in the following credentials:
-
-```
-username: user
-password: password
-endpoint: http://localhost:8080/admin
-```
-
-> [!NOTE]  
-> If you are seeing "An unexpected error occurred" when trying to connect, try disabling your adblock.
-
 ## Inspiration
 
 The UI is heavily inspired by [Drizzle Studio](https://orm.drizzle.team/drizzle-studio/overview).

assets/sqlite-admin-filtering.png

@@ -84,7 +84,7 @@ func getRouter(dbPath, username, password string) *chi.Mux {
 		Password: password,
 		Logger:   logger,
 	}
-	sh := sqliteadmin.NewHandler(config)
+	admin := sqliteadmin.New(config)
 
 	r := chi.NewRouter()
 	r.Use(middleware.Logger)
@@ -95,7 +95,7 @@ func getRouter(dbPath, username, password string) *chi.Mux {
 		AllowCredentials: true,
 		MaxAge:           300,
 	}))
-	r.Post("/", sh.HandlePost)
+	r.Post("/", admin.HandlePost)
 
 	return r
 }

cmd/sqliteadmin/serve.go

@@ -24,14 +24,13 @@ func main() {
 
 	logger := slog.Default()
 
-	// Setup the handler for SQLiteAdmin
 	config := sqliteadmin.Config{
 		DB:       db,
 		Username: "user",
 		Password: "password",
 		Logger:   logger,
 	}
-	sh := sqliteadmin.NewHandler(config)
+	admin := sqliteadmin.New(config)
 
 	r := chi.NewRouter()
 	r.Use(middleware.Logger)
@@ -46,7 +45,7 @@ func main() {
 		w.Write([]byte("welcome"))
 	})
 	// Setup the handler for SQLiteAdmin
-	r.Post("/admin", sh.HandlePost)
+	r.Post("/admin", admin.HandlePost)
 
 	fmt.Printf("--> Starting server on %s\n", addr)
 	http.ListenAndServe(":8080", r)

examples/chi/main.go

@@ -14,7 +14,6 @@ import (
 	"github.com/joelseq/sqliteadmin-go"
 	"github.com/rs/cors"
 	_ "modernc.org/sqlite"
-	// "github.com/rs/cors"
 )
 
 func main() {
@@ -30,7 +29,7 @@ func main() {
 		Password: "password",
 		Logger:   logger,
 	}
-	sHandler := sqliteadmin.NewHandler(config)
+	admin := sqliteadmin.New(config)
 
 	mux := http.NewServeMux()
 
@@ -40,7 +39,7 @@ func main() {
 
 	mux.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) {
 		if r.Method == "POST" {
-			sHandler.HandlePost(w, r)
+			admin.HandlePost(w, r)
 		}
 	})
 
@@ -92,10 +91,3 @@ func gracefulShutdown(apiServer *http.Server, done chan bool) {
 	// Notify the main goroutine that the shutdown is complete
 	done <- true
 }
-
-// func enableCors(w http.ResponseWriter) {
-// 	w.Header().Set("Access-Control-Allow-Origin", "*")
-// 	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-// 	w.Header().Set("Access-Control-Allow-Headers", "Accept, Authorization, Content-Type")
-// 	w.Header().Set("Access-Control-Allow-Credentials", "true")
-// }

examples/stdlib/stdlib.go

@@ -11,17 +11,17 @@ import (
 	"github.com/mitchellh/mapstructure"
 )
 
-func (h *Handler) ping(w http.ResponseWriter) {
-	h.logger.Info("Command: Ping")
+func (a *Admin) ping(w http.ResponseWriter) {
+	a.logger.Info("Command: Ping")
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
 }
 
-func (h *Handler) listTables(w http.ResponseWriter) {
-	h.logger.Info("Command: ListTables")
-	rows, err := h.db.Query("SELECT name FROM sqlite_master WHERE type='table';")
+func (a *Admin) listTables(w http.ResponseWriter) {
+	a.logger.Info("Command: ListTables")
+	rows, err := a.db.Query("SELECT name FROM sqlite_master WHERE type='table';")
 	if err != nil {
-		h.logger.Error(fmt.Sprintf("Error listing tables: %v", err))
+		a.logger.Error(fmt.Sprintf("Error listing tables: %v", err))
 		writeError(w, apiErrSomethingWentWrong())
 		return
 	}
@@ -31,7 +31,7 @@ func (h *Handler) listTables(w http.ResponseWriter) {
 	for rows.Next() {
 		var table string
 		if err := rows.Scan(&table); err != nil {
-			h.logger.Error(fmt.Sprintf("Error scanning rows: %v", err))
+			a.logger.Error(fmt.Sprintf("Error scanning rows: %v", err))
 			writeError(w, apiErrSomethingWentWrong())
 			return
 		}
@@ -41,7 +41,7 @@ func (h *Handler) listTables(w http.ResponseWriter) {
 	json.NewEncoder(w).Encode(map[string][]string{"tables": tables})
 }
 
-func (h *Handler) getTable(w http.ResponseWriter, params map[string]interface{}) {
+func (a *Admin) getTable(w http.ResponseWriter, params map[string]interface{}) {
 	// Parse table name
 	table, ok := params["tableName"].(string)
 	if !ok {
@@ -69,44 +69,44 @@ func (h *Handler) getTable(w http.ResponseWriter, params map[string]interface{})
 		}
 	}
 
-	h.logger.Info(fmt.Sprintf("Command: GetTable, table=%s, limit=%d, offset=%d", table, limit, offset))
+	a.logger.Info(fmt.Sprintf("Command: GetTable, table=%s, limit=%d, offset=%d", table, limit, offset))
 
 	var condition *Condition
 	conditionParam, ok := params["condition"]
 	if ok {
-		condition, ok = toCondition(conditionParam, h.logger)
+		condition, ok = toCondition(conditionParam, a.logger)
 		if !ok {
 			writeError(w, apiErrBadRequest("Invalid condition"))
 			return
 		}
-		h.logger.Debug(fmt.Sprintf("Condition provided: %v", condition))
+		a.logger.Debug(fmt.Sprintf("Condition provided: %v", condition))
 	} else {
-		h.logger.Debug("No condition provided")
+		a.logger.Debug("No condition provided")
 	}
 
-	data, err := queryTable(h.db, table, condition, limit, offset, h.logger)
+	data, err := queryTable(a.db, table, condition, limit, offset, a.logger)
 	if err != nil {
-		h.logger.Error(fmt.Sprintf("Error querying table: %v", err))
+		a.logger.Error(fmt.Sprintf("Error querying table: %v", err))
 		writeError(w, apiErrSomethingWentWrong())
 		return
 	}
 	response := map[string]interface{}{"rows": data}
 
 	if params["includeInfo"] == true {
-		tableInfo, err := getTableInfo(h.db, table)
+		tableInfo, err := getTableInfo(a.db, table)
 		if err != nil {
-			h.logger.Error(fmt.Sprintf("Error getting table info: %v", err))
+			a.logger.Error(fmt.Sprintf("Error getting table info: %v", err))
 			writeError(w, apiErrSomethingWentWrong())
 			return
 		}
 		response["tableInfo"] = tableInfo
 	}
-	h.logger.Info(fmt.Sprintf("Fetched %d rows", len(data)))
+	a.logger.Info(fmt.Sprintf("Fetched %d rows", len(data)))
 
 	json.NewEncoder(w).Encode(response)
 }
 
-func (h *Handler) deleteRows(w http.ResponseWriter, params map[string]interface{}) {
+func (a *Admin) deleteRows(w http.ResponseWriter, params map[string]interface{}) {
 	table, ok := params["tableName"].(string)
 	if !ok {
 		writeError(w, apiErrBadRequest(ErrMissingTableName.Error()))
@@ -119,32 +119,32 @@ func (h *Handler) deleteRows(w http.ResponseWriter, params map[string]interface{
 		return
 	}
 
-	h.logger.Info(fmt.Sprintf("Command: DeleteRows, table=%s, ids=%v", table, ids))
+	a.logger.Info(fmt.Sprintf("Command: DeleteRows, table=%s, ids=%v", table, ids))
 
-	exists, err := checkTableExists(h.db, table)
+	exists, err := checkTableExists(a.db, table)
 	if err != nil {
-		h.logger.Error(fmt.Sprintf("Error checking table existence: %v", err))
+		a.logger.Error(fmt.Sprintf("Error checking table existence: %v", err))
 		writeError(w, apiErrSomethingWentWrong())
 		return
 	}
 	if !exists {
-		h.logger.Error(fmt.Sprintf("Error table does not exist: %s", table))
+		a.logger.Error(fmt.Sprintf("Error table does not exist: %s", table))
 		writeError(w, apiErrBadRequest(ErrInvalidInput.Error()))
 		return
 	}
 
-	rowsAffected, err := batchDelete(h.db, table, ids)
+	rowsAffected, err := batchDelete(a.db, table, ids)
 	if err != nil {
-		h.logger.Error(fmt.Sprintf("Error deleting rows from table: %v", err))
+		a.logger.Error(fmt.Sprintf("Error deleting rows from table: %v", err))
 		writeError(w, apiErrSomethingWentWrong())
 		return
 	}
-	h.logger.Info(fmt.Sprintf("Deleted %d row(s)", rowsAffected))
+	a.logger.Info(fmt.Sprintf("Deleted %d row(s)", rowsAffected))
 
 	json.NewEncoder(w).Encode(map[string]string{"rowsAffected": fmt.Sprintf("%d", rowsAffected)})
 }
 
-func (h *Handler) updateRow(w http.ResponseWriter, params map[string]interface{}) {
+func (a *Admin) updateRow(w http.ResponseWriter, params map[string]interface{}) {
 	table, ok := params["tableName"].(string)
 	if !ok {
 		writeError(w, apiErrBadRequest(ErrMissingTableName.Error()))
@@ -157,15 +157,15 @@ func (h *Handler) updateRow(w http.ResponseWriter, params map[string]interface{}
 		return
 	}
 
-	h.logger.Info(fmt.Sprintf("Command: UpdateRow, table=%s, row=%v", table, row))
+	a.logger.Info(fmt.Sprintf("Command: UpdateRow, table=%s, row=%v", table, row))
 
-	err := editRow(h.db, table, row)
+	err := editRow(a.db, table, row)
 	if err != nil {
-		h.logger.Error(fmt.Sprintf("Error editing row: %v", err))
+		a.logger.Error(fmt.Sprintf("Error editing row: %v", err))
 		writeError(w, apiErrSomethingWentWrong())
 		return
 	}
-	h.logger.Info("Row updated")
+	a.logger.Info("Row updated")
 
 	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
 }