example: remote

Author: Peyton-Spencer

example/remote/.gitignore

@@ -0,0 +1,3 @@
+.env.*
+!.env.example
+local.db

example/remote/README.md

@@ -0,0 +1,10 @@
+# Run
+
+```
+go run main.go
+```
+
+- Environment variables are loaded from `envs/.env.local` by default.
+- An example `.env.local` will be created if it doesn't exist.
+- `local` mode will save a local.db file in this directory.
+- `staging` and `prod` can be setup by creating `envs/.env.staging` and `envs/.env.prod` and setting the values from your Turso instance.

example/remote/envs/.env.example

@@ -0,0 +1,2 @@
+TURSO_URL=file:./local.db
+TURSO_AUTH_TOKEN=your-auth-token

example/remote/envs/envs.go

@@ -0,0 +1,141 @@
+package envs
+
+import (
+	"bufio"
+	"embed"
+	"errors"
+	"fmt"
+	"log/slog"
+	"os"
+	"strings"
+)
+
+//go:embed .env.*
+var fs embed.FS
+
+// Environment Variables
+var (
+	TURSO_URL        string
+	TURSO_AUTH_TOKEN string
+	REMOTE_ENV       Env
+)
+
+type Env string
+
+const (
+	EnvLocal   Env = "local"
+	EnvStaging Env = "staging"
+	EnvProd    Env = "prod"
+)
+
+func (e Env) String() string {
+	return string(e)
+}
+
+type EnvFile string
+
+func (e Env) EnvFile() EnvFile {
+	return EnvFile(".env." + e.String())
+}
+
+func (e EnvFile) Load() error {
+	file, err := fs.Open(string(e))
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
+		parts := strings.SplitN(line, "=", 2)
+		if len(parts) != 2 {
+			continue
+		}
+		key := strings.TrimSpace(parts[0])
+		value := strings.TrimSpace(parts[1])
+		os.Setenv(key, value)
+	}
+	return scanner.Err()
+}
+
+var didLoad = false
+
+func Load() error {
+	if didLoad {
+		return nil
+	}
+
+	env, ok := os.LookupEnv("REMOTE_ENV")
+	if !ok {
+		slog.Info("REMOTE_ENV not set, using local")
+		env = "local"
+	}
+	REMOTE_ENV = Env(env)
+
+	eFile := REMOTE_ENV.EnvFile()
+
+	// Check if .env.local exists, if not create it with default values
+	if REMOTE_ENV == EnvLocal {
+		if _, err := fs.Open(".env.local"); errors.Is(err, os.ErrNotExist) {
+			slog.Info("Creating default .env.local file")
+			defaultEnv := []byte("TURSO_URL=file:./local.db\nTURSO_AUTH_TOKEN=your-auth-token")
+			if err := os.WriteFile("envs/.env.local", defaultEnv, 0644); err != nil {
+				return fmt.Errorf("failed to create default .env.local: %w", err)
+			}
+			slog.Info("Created default .env.local file. The defaults will work for local testing, but you'll need to update the variables to connect to your Turso instance")
+			slog.Info("Run `go run .` to start the application")
+			os.Exit(1)
+		}
+	}
+
+	slog.Info("Loading environment variables", "file", eFile)
+	if err := eFile.Load(); err != nil {
+		return err
+	}
+
+	envs := []envLookup{
+		{&TURSO_URL, "TURSO_URL"},
+		{&TURSO_AUTH_TOKEN, "TURSO_AUTH_TOKEN"},
+	}
+	if err := lookupEnvs(envs); err != nil {
+		return err
+	}
+
+	didLoad = true
+	slog.Debug("Loaded environment variables",
+		"REMOTE_ENV", REMOTE_ENV,
+		"DB_URL", TURSO_URL,
+	)
+	return nil
+}
+
+type envLookup struct {
+	ptr *string
+	key string
+}
+
+func lookupEnvs(envs []envLookup) error {
+	var errorSlice []error
+	for _, env := range envs {
+		val, err := lookupEnv(env.key)
+		if err != nil {
+			errorSlice = append(errorSlice, err)
+		}
+		*env.ptr = val
+	}
+	if len(errorSlice) > 0 {
+		return fmt.Errorf("failed to lookup envs: %w", errors.Join(errorSlice...))
+	}
+	return nil
+}
+
+func lookupEnv(key string) (string, error) {
+	val, ok := os.LookupEnv(key)
+	if !ok {
+		return "", fmt.Errorf("env %s not set", key)
+	}
+	return val, nil
+}

example/remote/main.go

@@ -0,0 +1,124 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"log/slog"
+	"os"
+	"time"
+
+	_ "github.com/tursodatabase/go-libsql"
+	"github.com/tursodatabase/go-libsql/example/remote/envs"
+)
+
+func main() {
+	setupSlog()
+	if err := run(); err != nil {
+		slog.Error("error running example", "error", err)
+		os.Exit(1)
+	}
+}
+
+func run() (err error) {
+	err = envs.Load()
+	if err != nil {
+		return fmt.Errorf("error loading environment variables: %w", err)
+	}
+	// Get database URL and auth token from environment variables
+	dbUrl := envs.TURSO_URL
+	if dbUrl == "" {
+		return fmt.Errorf("TURSO_URL environment variable not set")
+	}
+
+	authToken := os.Getenv("TURSO_AUTH_TOKEN")
+	if authToken != "" {
+		dbUrl += "?authToken=" + authToken
+	}
+
+	// Open database connection
+	db, err := sql.Open("libsql", dbUrl)
+	if err != nil {
+		return fmt.Errorf("error opening cloud db: %w", err)
+	}
+	defer func() {
+		if closeErr := db.Close(); closeErr != nil {
+			slog.Error("error closing libsql db", "error", closeErr)
+			if err == nil {
+				err = closeErr
+			}
+		} else {
+			slog.Debug("closed libsql db")
+		}
+	}()
+	// Configure connection pool: https://github.com/tursodatabase/go-libsql/issues/13
+	db.SetConnMaxIdleTime(9 * time.Second)
+
+	// Create test table
+	_, err = db.Exec("CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, name TEXT)")
+	if err != nil {
+		return fmt.Errorf("error creating table: %w", err)
+	}
+
+	// Check if test data already exists
+	var exists bool
+	err = db.QueryRow("SELECT EXISTS(SELECT 1 FROM test WHERE id = 1)").Scan(&exists)
+	if err != nil {
+		return fmt.Errorf("error checking existing data: %w", err)
+	}
+
+	// Insert test data only if it doesn't exist
+	if !exists {
+		_, err = db.Exec("INSERT INTO test (id, name) VALUES (?, ?)", 1, "remote test")
+		if err != nil {
+			return fmt.Errorf("error inserting data: %w", err)
+		}
+		slog.Debug("inserted test data")
+	} else {
+		slog.Debug("test data already exists, skipping insert")
+	}
+
+	// Query the data
+	rows, err := db.Query("SELECT * FROM test")
+	if err != nil {
+		return fmt.Errorf("error querying data: %w", err)
+	}
+	defer func() {
+		if closeErr := rows.Close(); closeErr != nil {
+			slog.Error("error closing rows", "error", closeErr)
+			if err == nil {
+				err = closeErr
+			}
+		}
+	}()
+
+	// Print results
+	for rows.Next() {
+		var id int
+		var name string
+		if err := rows.Scan(&id, &name); err != nil {
+			return fmt.Errorf("error scanning row: %w", err)
+		}
+		fmt.Printf("Row: id=%d, name=%s\n", id, name)
+	}
+	if err := rows.Err(); err != nil {
+		return fmt.Errorf("error iterating rows: %w", err)
+	}
+
+	slog.Debug("successfully connected and executed queries", "url", envs.TURSO_URL)
+	return nil
+}
+
+func setupSlog() {
+	// Configure slog to only show log level
+	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{
+		Level: slog.LevelDebug,
+		ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
+			// Remove time attribute
+			if a.Key == "time" {
+				return slog.Attr{}
+			}
+			return a
+		},
+	}))
+	slog.SetDefault(logger)
+}