axiodb 16.2.1 → 17.0.0

package/README.md

@@ -341,7 +341,7 @@ The rule: the `-e AXIODB_TLS_CERT_PATH=...` value must always match the *right-h
 
 ## 💻 AxioDB CLI — Command Line Interface
 
-A Go-based CLI tool for interacting with AxioDB servers via the TCP protocol. Supports all database operations with both single-command and interactive REPL modes.
+A Go-based CLI tool for interacting with AxioDB servers via the TCP protocol. Supports all database operations with both single-command and interactive REPL modes. Export and import databases via the HTTP API.
 
 ### Quick Install
 
@@ -399,14 +399,27 @@ axiodb -c axiodb://127.0.0.1:27019 -u admin -p admin connect
 axiodb -c axiodb://127.0.0.1:27019 --tls --tls-cert ./cert.pem connect
 ```
 
+**Export database (via HTTP API):**
+```bash
+axiodb export mydb --http-host localhost --http-port 27018 -u admin -p secret
+# Saves mydb.tar.gz in current directory
+```
+
+**Import database (via HTTP API):**
+```bash
+axiodb import ./backups/mydb.tar.gz --http-host localhost --http-port 27018 -u admin -p secret
+# Tab completes .tar.gz file paths
+```
+
 ### Features
 
-- **All 21 TCP commands:** database, collection, document CRUD, aggregation, indexing
+- **All 23 commands:** database, collection, document CRUD, aggregation, indexing, export, import
 - **Interactive REPL:** MongoDB shell syntax (`use`, `show dbs`, `db.coll.find()`)
+- **Export & Import:** backup/restore databases via HTTP API, tab-completes file paths
 - **TLS support:** `--tls`, `--tls-cert`, `--tls-skip-verify`
-- **Auth support:** `-u` / `-p` flags
+- **Auth support:** `-u` / `-p` flags (TCP and HTTP)
 - **JSON output:** `--output json` for scripting
-- **Tab autocomplete** in REPL mode
+- **Tab autocomplete** in REPL mode and file path completion
 
 👉 **[Full CLI Documentation](https://github.com/nexoral/AxioDB/tree/main/cli)**
 

package/cli/VERSION

@@ -1 +1 @@
-16.2.1
+17.0.0

package/cli/cmd/db_export.go

@@ -0,0 +1,66 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/nexoral/axiodb-cli/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var exportCmd = &cobra.Command{
+	Use:   "export <dbname>",
+	Short: "Export a database to a .tar.gz file via HTTP",
+	Long:  "Export an AxioDB database to a .tar.gz archive. Uses the HTTP API (port 27018), not TCP.",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		dbName := args[0]
+		cfg, err := config.FromFlags(cmd)
+		if err != nil {
+			return err
+		}
+
+		if cfg.Username == "" || cfg.Password == "" {
+			return fmt.Errorf("username and password required for HTTP auth (-u, -p)")
+		}
+
+		client := cfg.NewHTTPClient()
+
+		fmt.Fprintf(os.Stderr, "Logging in to %s:%d...\n", cfg.HTTPHost, cfg.HTTPPort)
+		if err := client.Login(cfg.Username, cfg.Password); err != nil {
+			return err
+		}
+		defer client.Logout()
+
+		fmt.Fprintf(os.Stderr, "Exporting %s...\n", dbName)
+		filename, size, err := client.Export(dbName)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintf(os.Stderr, "Exported %s (%s)\n", filename, formatBytes(size))
+		return nil
+	},
+}
+
+func formatBytes(bytes int64) string {
+	const (
+		KB = 1024
+		MB = 1024 * KB
+		GB = 1024 * MB
+	)
+	switch {
+	case bytes >= GB:
+		return fmt.Sprintf("%.1f GB", float64(bytes)/float64(GB))
+	case bytes >= MB:
+		return fmt.Sprintf("%.1f MB", float64(bytes)/float64(MB))
+	case bytes >= KB:
+		return fmt.Sprintf("%.1f KB", float64(bytes)/float64(KB))
+	default:
+		return fmt.Sprintf("%d B", bytes)
+	}
+}
+
+func init() {
+	rootCmd.AddCommand(exportCmd)
+}

package/cli/cmd/db_import.go

@@ -0,0 +1,84 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/nexoral/axiodb-cli/internal/config"
+	"github.com/spf13/cobra"
+)
+
+var importCmd = &cobra.Command{
+	Use:   "import <file>",
+	Short: "Import a database from a .tar.gz file via HTTP",
+	Long:  "Import an AxioDB database from a .tar.gz archive. Uses the HTTP API (port 27018), not TCP.",
+	Args:  cobra.ExactArgs(1),
+	ValidArgsFunction: func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		dir := "."
+		prefix := toComplete
+
+		if idx := strings.LastIndex(toComplete, "/"); idx >= 0 {
+			dir = toComplete[:idx+1]
+			prefix = toComplete[idx+1:]
+		}
+
+		entries, err := os.ReadDir(dir)
+		if err != nil {
+			return nil, cobra.ShellCompDirectiveDefault
+		}
+
+		var completions []string
+		for _, entry := range entries {
+			if entry.IsDir() {
+				continue
+			}
+			name := entry.Name()
+			if strings.HasPrefix(name, prefix) && strings.HasSuffix(name, ".tar.gz") {
+				completions = append(completions, filepath.Join(dir, name))
+			}
+		}
+		return completions, cobra.ShellCompDirectiveNoFileComp
+	},
+	RunE: func(cmd *cobra.Command, args []string) error {
+		filePath := args[0]
+		cfg, err := config.FromFlags(cmd)
+		if err != nil {
+			return err
+		}
+
+		if cfg.Username == "" || cfg.Password == "" {
+			return fmt.Errorf("username and password required for HTTP auth (-u, -p)")
+		}
+
+		info, err := os.Stat(filePath)
+		if err != nil {
+			return fmt.Errorf("file not found: %s", filePath)
+		}
+		if info.IsDir() {
+			return fmt.Errorf("not a file: %s", filePath)
+		}
+
+		client := cfg.NewHTTPClient()
+
+		fmt.Fprintf(os.Stderr, "Logging in to %s:%d...\n", cfg.HTTPHost, cfg.HTTPPort)
+		if err := client.Login(cfg.Username, cfg.Password); err != nil {
+			return err
+		}
+		defer client.Logout()
+
+		fmt.Fprintf(os.Stderr, "Importing %s...\n", filepath.Base(filePath))
+		dbName, err := client.Import(filePath)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintf(os.Stderr, "Imported database: %s\n", dbName)
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(importCmd)
+}

package/cli/cmd/root.go

@@ -33,4 +33,6 @@ func init() {
 	rootCmd.PersistentFlags().Int("timeout", 30, "Request timeout in seconds")
 	rootCmd.PersistentFlags().String("db", "", "Database name")
 	rootCmd.PersistentFlags().String("collection", "", "Collection name")
+	rootCmd.PersistentFlags().String("http-host", "localhost", "HTTP server host (for export/import)")
+	rootCmd.PersistentFlags().Int("http-port", 27018, "HTTP server port (for export/import)")
 }

package/cli/internal/config/config.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/nexoral/axiodb-cli/pkg/httpclient"
 	"github.com/nexoral/axiodb-cli/pkg/protocol"
 	"github.com/spf13/cobra"
 )
@@ -23,6 +24,8 @@ type Config struct {
 	Timeout       int
 	DB            string
 	Collection    string
+	HTTPHost      string
+	HTTPPort      int
 }
 
 func FromFlags(cmd *cobra.Command) (*Config, error) {
@@ -40,6 +43,8 @@ func FromFlags(cmd *cobra.Command) (*Config, error) {
 	cfg.Timeout, _ = cmd.Flags().GetInt("timeout")
 	cfg.DB, _ = cmd.Flags().GetString("db")
 	cfg.Collection, _ = cmd.Flags().GetString("collection")
+	cfg.HTTPHost, _ = cmd.Flags().GetString("http-host")
+	cfg.HTTPPort, _ = cmd.Flags().GetInt("http-port")
 
 	if cfg.ConnString != "" {
 		host, port, err := parseConnectionString(cfg.ConnString)
@@ -109,3 +114,7 @@ func GetCollectionContext(cmd *cobra.Command) string {
 	coll, _ := cmd.Flags().GetString("collection")
 	return coll
 }
+
+func (c *Config) NewHTTPClient() *httpclient.HTTPClient {
+	return httpclient.New(c.HTTPHost, c.HTTPPort, time.Duration(c.Timeout)*time.Second)
+}

package/cli/pkg/httpclient/client.go

@@ -0,0 +1,160 @@
+package httpclient
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/http/cookiejar"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+type HTTPClient struct {
+	baseURL    string
+	httpClient *http.Client
+}
+
+func New(host string, port int, timeout time.Duration) *HTTPClient {
+	jar, _ := cookiejar.New(nil)
+	return &HTTPClient{
+		baseURL: fmt.Sprintf("http://%s:%d", host, port),
+		httpClient: &http.Client{
+			Timeout: timeout,
+			Jar:     jar,
+		},
+	}
+}
+
+func (c *HTTPClient) Login(username, password string) error {
+	body, _ := json.Marshal(map[string]string{
+		"username": username,
+		"password": password,
+	})
+
+	resp, err := c.httpClient.Post(c.baseURL+"/api/auth/login", "application/json", bytes.NewReader(body))
+	if err != nil {
+		return fmt.Errorf("login request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode == http.StatusOK {
+		return nil
+	}
+
+	var errResp struct {
+		Message string `json:"message"`
+	}
+	json.NewDecoder(resp.Body).Decode(&errResp)
+	msg := errResp.Message
+	if msg == "" {
+		msg = resp.Status
+	}
+	return fmt.Errorf("login failed: %s", msg)
+}
+
+func (c *HTTPClient) Logout() error {
+	resp, err := c.httpClient.Post(c.baseURL+"/api/auth/logout", "application/json", nil)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return nil
+}
+
+func (c *HTTPClient) Export(dbName string) (string, int64, error) {
+	url := fmt.Sprintf("%s/api/db/export-database/?dbName=%s", c.baseURL, dbName)
+	resp, err := c.httpClient.Get(url)
+	if err != nil {
+		return "", 0, fmt.Errorf("export request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		var errResp struct {
+			Message string `json:"message"`
+		}
+		json.NewDecoder(resp.Body).Decode(&errResp)
+		msg := errResp.Message
+		if msg == "" {
+			msg = resp.Status
+		}
+		return "", 0, fmt.Errorf("export failed: %s", msg)
+	}
+
+	filename := dbName + ".tar.gz"
+	if cd := resp.Header.Get("Content-Disposition"); cd != "" {
+		if idx := strings.Index(cd, "filename="); idx >= 0 {
+			name := cd[idx+9:]
+			name = strings.Trim(name, "\"")
+			if name != "" {
+				filename = filepath.Base(name)
+			}
+		}
+	}
+
+	out, err := os.Create(filename)
+	if err != nil {
+		return "", 0, fmt.Errorf("create file: %w", err)
+	}
+	defer out.Close()
+
+	written, err := io.Copy(out, resp.Body)
+	if err != nil {
+		os.Remove(filename)
+		return "", 0, fmt.Errorf("write file: %w", err)
+	}
+
+	return filename, written, nil
+}
+
+func (c *HTTPClient) Import(filePath string) (string, error) {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return "", fmt.Errorf("open file: %w", err)
+	}
+	defer file.Close()
+
+	var body bytes.Buffer
+	writer := multipart.NewWriter(&body)
+	part, err := writer.CreateFormFile("file", filepath.Base(filePath))
+	if err != nil {
+		return "", fmt.Errorf("create form file: %w", err)
+	}
+	if _, err := io.Copy(part, file); err != nil {
+		return "", fmt.Errorf("write form data: %w", err)
+	}
+	writer.Close()
+
+	resp, err := c.httpClient.Post(
+		c.baseURL+"/api/db/import-database/",
+		writer.FormDataContentType(),
+		&body,
+	)
+	if err != nil {
+		return "", fmt.Errorf("import request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	var result struct {
+		Message  string `json:"message"`
+		Database string `json:"database"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return "", fmt.Errorf("parse response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		msg := result.Message
+		if msg == "" {
+			msg = fmt.Sprintf("HTTP %d", resp.StatusCode)
+		}
+		return "", fmt.Errorf("import failed: %s", msg)
+	}
+
+	return result.Database, nil
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axiodb",
-  "version": "16.2.1",
+  "version": "17.0.0",
   "description": "The Pure JavaScript Alternative to SQLite. Embedded NoSQL database for Node.js with MongoDB-style queries, zero native dependencies, built-in InMemoryCache, and web GUI. Perfect for desktop apps, CLI tools, and embedded systems. No compilation, no platform issues—pure JavaScript from npm install to production.",
   "main": "./lib/config/DB.js",
   "types": "./lib/config/DB.d.ts",