Add turso db export command (#973)

This adds a `turso db export` command, which exports a Turso database to
a local SQLite file. The export command does not generate a WAL file so
the database is a snapshot of time at the beginning of the current
generation, not the latest database version. You need to, therefore,
sync the database using Turso SDK if you need the latest data.

Example usage:

1. Export the `hello` database as `hello.db`:

```
turso db export hello
```

2. Overwrite an existing database file:

```
turso db export hello --overwrite
```

3. Generate metadata with the export:

```
turso db export hello --with-metadata
```

4. Output `hello` database to the `world.db` file:

```
turso db export hello --output-file world.db
```

Author: penberg

internal/cmd/db_export.go

@@ -0,0 +1,66 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var withMetadata bool
+var overwriteExport bool
+var outputFile string
+
+var exportCmd = &cobra.Command{
+	Use:   "export <database>",
+	Short: "Export a database snapshot from Turso to SQLite file.",
+	Long: `Export a database snapshot from Turso to SQLite file.
+
+This command exports a snapshot of the current generation of a Turso database
+to a local SQLite file.  Note that the exported file may not contain the
+latest changes. Use SDK to sync the database after exporting  to ensure you
+have the most recent version.`,
+	Args: cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cmd.SilenceUsage = true
+		dbName := args[0]
+		if outputFile == "" {
+			outputFile = dbName + ".db"
+		}
+		err := ExportDatabase(dbName, outputFile, withMetadata, overwriteExport)
+		if err != nil {
+			return fmt.Errorf("failed to export database: %w", err)
+		}
+		fmt.Printf("Exported database to %s\n", outputFile)
+		return nil
+	},
+}
+
+func ExportDatabase(dbName, outputFile string, withMetadata bool, overwrite bool) error {
+	if !overwrite {
+		if _, err := os.Stat(outputFile); err == nil {
+			return fmt.Errorf("file %s already exists, use `--overwrite` flag to overwrite it", outputFile)
+		}
+	}
+	client, err := authedTursoClient()
+	if err != nil {
+		return err
+	}
+	db, err := getDatabase(client, dbName)
+	if err != nil {
+		return fmt.Errorf("failed to find database: %w", err)
+	}
+	dbUrl := getDatabaseHttpUrl(&db)
+	err = client.Databases.Export(dbName, dbUrl, outputFile, withMetadata, overwrite)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func init() {
+	exportCmd.Flags().BoolVar(&withMetadata, "with-metadata", false, "Include metadata in the export.")
+	exportCmd.Flags().BoolVar(&overwriteExport, "overwrite", false, "Overwrite output file if it exists.")
+	exportCmd.Flags().StringVar(&outputFile, "output-file", "", "Specify the output file name (default: <database>.db)")
+	dbCmd.AddCommand(exportCmd)
+}

internal/turso/databases.go

@@ -222,8 +222,11 @@ func (d *DatabasesClient) UploadDatabaseAWS(resp *CreateDatabaseResponse, group
 		return nil, fmt.Errorf("could not create database token: %w", err)
 	}
 
-	hostname := resp.Database.Hostname
-	tursoServerClient, err := NewTursoServerClient(hostname, token, d.client.cliVersion, d.client.Org)
+	baseURL, err := url.Parse(fmt.Sprintf("https://%s", resp.Database.Hostname))
+	if err != nil {
+		return nil, fmt.Errorf("unable to create TursoServerClient: %v", err)
+	}
+	tursoServerClient, err := NewTursoServerClient(baseURL, token, d.client.cliVersion, d.client.Org)
 	if err != nil {
 		return nil, fmt.Errorf("could not create Turso server client: %w", err)
 	}
@@ -262,6 +265,27 @@ func (d *DatabasesClient) UploadDatabaseAWS(resp *CreateDatabaseResponse, group
 	return resp, nil
 }
 
+func (d *DatabasesClient) Export(dbName, dbUrl, outputFile string, withMetadata bool, overwrite bool) error {
+	if !overwrite {
+		if _, err := os.Stat(outputFile); err == nil {
+			return fmt.Errorf("file %s already exists, use `--overwrite` flag to overwrite it", outputFile)
+		}
+	}
+	token, err := d.Token(dbName, "1h", false, nil)
+	if err != nil {
+		return fmt.Errorf("could not create database token: %w", err)
+	}
+	baseURL, err := url.Parse(dbUrl)
+	if err != nil {
+		return fmt.Errorf("could not parse database URL: %w", err)
+	}
+	tursoServerClient, err := NewTursoServerClient(baseURL, token, d.client.cliVersion, d.client.Org)
+	if err != nil {
+		return fmt.Errorf("could not create Turso server client: %w", err)
+	}
+	return tursoServerClient.Export(outputFile, withMetadata)
+}
+
 func (d *DatabasesClient) Seed(name string, dbFile *os.File) error {
 	url := d.URL(fmt.Sprintf("/%s/seed", name))
 	res, err := d.client.Upload(url, dbFile)

internal/turso/tursoServer.go

@@ -1,8 +1,11 @@
 package turso
 
 import (
+	"encoding/binary"
+	"encoding/json"
 	"errors"
 	"fmt"
+	"hash/crc32"
 	"io"
 	"net/http"
 	"net/url"
@@ -42,11 +45,7 @@ type TursoServerClient struct {
 	client *Client
 }
 
-func NewTursoServerClient(tenantHostname string, token string, cliVersion string, org string) (TursoServerClient, error) {
-	baseURL, err := url.Parse(fmt.Sprintf("https://%s", tenantHostname))
-	if err != nil {
-		return TursoServerClient{}, fmt.Errorf("unable to create TursoServerClient: %v", err)
-	}
+func NewTursoServerClient(baseURL *url.URL, token string, cliVersion string, org string) (TursoServerClient, error) {
 	newClient := New(baseURL, token, cliVersion, org)
 
 	return TursoServerClient{
@@ -98,3 +97,74 @@ func (i *TursoServerClient) UploadFile(filepath string, onUploadProgress func(pr
 
 	return nil
 }
+
+func (i *TursoServerClient) Export(outputFile string, withMetadata bool) error {
+	res, err := i.client.Get("/info", nil)
+	if err != nil {
+		return fmt.Errorf("failed to fetch database info: %w", err)
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return parseResponseError(res)
+	}
+	var info struct {
+		CurrentGeneration int `json:"current_generation"`
+	}
+	if err := json.NewDecoder(res.Body).Decode(&info); err != nil {
+		return fmt.Errorf("failed to decode /info response: %w", err)
+	}
+
+	exportRes, err := i.client.Get(fmt.Sprintf("/export/%d", info.CurrentGeneration), nil)
+	if err != nil {
+		return fmt.Errorf("failed to fetch export: %w", err)
+	}
+	defer exportRes.Body.Close()
+	if exportRes.StatusCode != http.StatusOK {
+		return parseResponseError(exportRes)
+	}
+
+	out, err := os.Create(outputFile)
+	if err != nil {
+		return fmt.Errorf("failed to create output file: %w", err)
+	}
+	defer out.Close()
+	if _, err := io.Copy(out, exportRes.Body); err != nil {
+		return fmt.Errorf("failed to write export to file: %w", err)
+	}
+
+	if withMetadata {
+		out, err := os.Create(outputFile + "-info")
+		if err != nil {
+			return fmt.Errorf("failed to create info file: %w", err)
+		}
+		defer out.Close()
+
+		hasher := crc32.New(crc32.MakeTable(crc32.IEEE))
+		var versionBytes [4]byte
+		var durableFrameNumBytes [4]byte
+		var generationBytes [4]byte
+		binary.LittleEndian.PutUint32(versionBytes[:], 0)
+		binary.LittleEndian.PutUint32(durableFrameNumBytes[:], 0)
+		binary.LittleEndian.PutUint32(generationBytes[:], uint32(info.CurrentGeneration))
+		hasher.Write(versionBytes[:])
+		hasher.Write(durableFrameNumBytes[:])
+		hasher.Write(generationBytes[:])
+		hash := int(hasher.Sum32())
+
+		metadata := struct {
+			Hash            int `json:"hash"`
+			Version         int `json:"version"`
+			DurableFrameNum int `json:"durable_frame_num"`
+			Generation      int `json:"generation"`
+		}{
+			Hash:            hash,
+			Version:         0,
+			DurableFrameNum: 0,
+			Generation:      info.CurrentGeneration,
+		}
+		if err := json.NewEncoder(out).Encode(metadata); err != nil {
+			return fmt.Errorf("failed to write metadata to file: %w", err)
+		}
+	}
+	return nil
+}