axiodb 20.3.2 → 20.3.3

package/cli/pkg/commands/document.go

@@ -1,203 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/nexoral/axiodb-cli/pkg/protocol"
-)
-
-func InsertDocument(client *protocol.Client, dbName, collectionName string, data interface{}) (*protocol.Response, error) {
-	resp, err := client.Send("INSERT_DOCUMENT", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"data":           data,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("insert document: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("insert document failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func InsertManyDocuments(client *protocol.Client, dbName, collectionName string, documents interface{}) (*protocol.Response, error) {
-	resp, err := client.Send("INSERT_MANY_DOCUMENTS", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"documents":      documents,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("insert many documents: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("insert many documents failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-type QueryOptions struct {
-	Query    interface{}
-	Limit    int
-	Skip     int
-	Sort     interface{}
-	FindOne  bool
-	Hint     string
-}
-
-func QueryDocuments(client *protocol.Client, dbName, collectionName string, opts QueryOptions) (*protocol.Response, error) {
-	params := map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-	}
-	if opts.Query != nil {
-		params["query"] = opts.Query
-	}
-	if opts.Limit > 0 {
-		params["limit"] = opts.Limit
-	}
-	if opts.Skip > 0 {
-		params["skip"] = opts.Skip
-	}
-	if opts.Sort != nil {
-		params["sort"] = opts.Sort
-	}
-	if opts.FindOne {
-		params["findOne"] = true
-	}
-	if opts.Hint != "" {
-		params["hint"] = opts.Hint
-	}
-
-	resp, err := client.Send("QUERY_DOCUMENTS", params)
-	if err != nil {
-		return nil, fmt.Errorf("query documents: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("query documents failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func QueryByID(client *protocol.Client, dbName, collectionName, id string) (*protocol.Response, error) {
-	resp, err := client.Send("QUERY_BY_ID", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"id":             id,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("query by id: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("query by id failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func FindDocumentsByIDs(client *protocol.Client, dbName, collectionName string, ids interface{}) (*protocol.Response, error) {
-	resp, err := client.Send("FIND_BY_IDS", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"ids":            ids,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("find documents by ids: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("find documents by ids failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func UpdateDocumentByID(client *protocol.Client, dbName, collectionName, id string, updateData interface{}) (*protocol.Response, error) {
-	resp, err := client.Send("UPDATE_DOCUMENT_BY_ID", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"id":             id,
-		"updateData":     updateData,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("update document: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("update document failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func UpdateDocumentsByQuery(client *protocol.Client, dbName, collectionName string, query, updateData interface{}, updateOne bool) (*protocol.Response, error) {
-	resp, err := client.Send("UPDATE_DOCUMENTS_BY_QUERY", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"query":          query,
-		"updateData":     updateData,
-		"updateOne":      updateOne,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("update documents by query: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("update documents by query failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func DeleteDocumentByID(client *protocol.Client, dbName, collectionName, id string) (*protocol.Response, error) {
-	resp, err := client.Send("DELETE_DOCUMENT_BY_ID", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"id":             id,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("delete document: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("delete document failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func DeleteDocumentsByQuery(client *protocol.Client, dbName, collectionName string, query interface{}, deleteOne bool) (*protocol.Response, error) {
-	resp, err := client.Send("DELETE_DOCUMENTS_BY_QUERY", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"query":          query,
-		"deleteOne":      deleteOne,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("delete documents by query: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("delete documents by query failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func Aggregate(client *protocol.Client, dbName, collectionName string, pipeline interface{}) (*protocol.Response, error) {
-	resp, err := client.Send("AGGREGATE", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"pipeline":       pipeline,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("aggregate: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("aggregate failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func TotalDocuments(client *protocol.Client, dbName, collectionName string) (*protocol.Response, error) {
-	resp, err := client.Send("TOTAL_DOCUMENTS", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("total documents: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("total documents failed: %s", resp.Error)
-	}
-	return resp, nil
-}

package/cli/pkg/commands/health.go

@@ -1,18 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/nexoral/axiodb-cli/pkg/protocol"
-)
-
-func Health(client *protocol.Client) (*protocol.Response, error) {
-	resp, err := client.Send("HEALTH", nil)
-	if err != nil {
-		return nil, fmt.Errorf("get health: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("get health failed: %s", resp.Error)
-	}
-	return resp, nil
-}

package/cli/pkg/commands/index.go

@@ -1,51 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/nexoral/axiodb-cli/pkg/protocol"
-)
-
-func CreateIndex(client *protocol.Client, dbName, collectionName string, fieldNames []string) (*protocol.Response, error) {
-	resp, err := client.Send("CREATE_INDEX", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"fieldNames":     fieldNames,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("create index: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("create index failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func DropIndex(client *protocol.Client, dbName, collectionName, indexName string) (*protocol.Response, error) {
-	resp, err := client.Send("DROP_INDEX", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-		"indexName":      indexName,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("drop index: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("drop index failed: %s", resp.Error)
-	}
-	return resp, nil
-}
-
-func ListIndexes(client *protocol.Client, dbName, collectionName string) (*protocol.Response, error) {
-	resp, err := client.Send("LIST_INDEXES", map[string]interface{}{
-		"dbName":         dbName,
-		"collectionName": collectionName,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("list indexes: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		return nil, fmt.Errorf("list indexes failed: %s", resp.Error)
-	}
-	return resp, nil
-}

package/cli/pkg/commands/transaction.go

@@ -1,84 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/nexoral/axiodb-cli/pkg/protocol"
-)
-
-type TransactionStep struct {
-	Operation       string      `json:"operation"`
-	Data            interface{} `json:"data,omitempty"`
-	Documents       interface{} `json:"documents,omitempty"`
-	Query           interface{} `json:"query,omitempty"`
-	UpdateData      interface{} `json:"updateData,omitempty"`
-	ID              string      `json:"id,omitempty"`
-	IDs             []string    `json:"ids,omitempty"`
-	SavepointName   string      `json:"savepointName,omitempty"`
-	UpdateOne       bool        `json:"updateOne,omitempty"`
-	DeleteOne       bool        `json:"deleteOne,omitempty"`
-}
-
-func BeginTransaction(client *protocol.Client, dbName, collectionName string) (*protocol.Response, error) {
-	return client.Send("BEGIN_TRANSACTION", map[string]interface{}{"dbName": dbName, "collectionName": collectionName})
-}
-
-func CommitTransaction(client *protocol.Client, transactionID string) (*protocol.Response, error) {
-	return client.Send("COMMIT_TRANSACTION", map[string]interface{}{"transactionId": transactionID})
-}
-
-func RollbackTransaction(client *protocol.Client, transactionID string) (*protocol.Response, error) {
-	return client.Send("ROLLBACK_TRANSACTION", map[string]interface{}{"transactionId": transactionID})
-}
-
-func Savepoint(client *protocol.Client, transactionID, savepointName string) (*protocol.Response, error) {
-	return client.Send("SAVEPOINT", map[string]interface{}{"transactionId": transactionID, "savepointName": savepointName})
-}
-
-func RollbackToSavepoint(client *protocol.Client, transactionID, savepointName string) (*protocol.Response, error) {
-	return client.Send("ROLLBACK_TO_SAVEPOINT", map[string]interface{}{"transactionId": transactionID, "savepointName": savepointName})
-}
-
-func ReleaseSavepoint(client *protocol.Client, transactionID, savepointName string) (*protocol.Response, error) {
-	return client.Send("RELEASE_SAVEPOINT", map[string]interface{}{"transactionId": transactionID, "savepointName": savepointName})
-}
-
-func RunTransaction(client *protocol.Client, dbName, collectionName string, steps []TransactionStep) (*protocol.Response, error) {
-	begin, err := BeginTransaction(client, dbName, collectionName)
-	if err != nil || begin.StatusCode >= 400 {
-		if err != nil { return nil, fmt.Errorf("begin transaction: %w", err) }
-		return nil, fmt.Errorf("begin transaction failed: %s", begin.Error)
-	}
-	transactionID, ok := begin.Data.(map[string]interface{})["transactionId"].(string)
-	if !ok || transactionID == "" {
-		return nil, fmt.Errorf("begin transaction returned no transaction ID")
-	}
-	base := map[string]interface{}{"dbName": dbName, "collectionName": collectionName, "transactionId": transactionID}
-	for _, step := range steps {
-		params := map[string]interface{}{}
-		for key, value := range base { params[key] = value }
-		switch step.Operation {
-		case "insert": params["data"] = step.Data
-		case "insert-many": params["documents"] = step.Documents
-		case "query": params["query"] = step.Query
-		case "find-by-ids": params["ids"] = step.IDs
-		case "update-by-id": params["id"], params["updateData"] = step.ID, step.UpdateData
-		case "update-by-query": params["query"], params["updateData"], params["updateOne"] = step.Query, step.UpdateData, step.UpdateOne
-		case "delete-by-id": params["id"] = step.ID
-		case "delete-by-query": params["query"], params["deleteOne"] = step.Query, step.DeleteOne
-		case "savepoint", "rollback-to-savepoint", "release-savepoint": params["savepointName"] = step.SavepointName
-		default: return nil, fmt.Errorf("unsupported transaction operation: %s", step.Operation)
-		}
-		command := map[string]string{"insert":"INSERT_DOCUMENT", "insert-many":"INSERT_MANY_DOCUMENTS", "query":"QUERY_DOCUMENTS", "find-by-ids":"FIND_BY_IDS", "update-by-id":"UPDATE_DOCUMENT_BY_ID", "update-by-query":"UPDATE_DOCUMENTS_BY_QUERY", "delete-by-id":"DELETE_DOCUMENT_BY_ID", "delete-by-query":"DELETE_DOCUMENTS_BY_QUERY", "savepoint":"SAVEPOINT", "rollback-to-savepoint":"ROLLBACK_TO_SAVEPOINT", "release-savepoint":"RELEASE_SAVEPOINT"}[step.Operation]
-		response, sendErr := client.Send(command, params)
-		if sendErr != nil || response.StatusCode >= 400 {
-			_, _ = RollbackTransaction(client, transactionID)
-			if sendErr != nil { return nil, fmt.Errorf("transaction %s: %w", step.Operation, sendErr) }
-			return nil, fmt.Errorf("transaction %s failed: %s", step.Operation, response.Error)
-		}
-	}
-	commit, err := CommitTransaction(client, transactionID)
-	if err != nil { return nil, fmt.Errorf("commit transaction: %w", err) }
-	if commit.StatusCode >= 400 { return nil, fmt.Errorf("commit transaction failed: %s", commit.Error) }
-	return commit, nil
-}

package/cli/pkg/httpclient/client.go

@@ -1,236 +0,0 @@
-package httpclient
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"mime/multipart"
-	"net/http"
-	"net/http/cookiejar"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-type HTTPClient struct {
-	baseURL    string
-	httpClient *http.Client
-}
-
-func (c *HTTPClient) doJSON(method, path string, payload interface{}) (map[string]interface{}, error) {
-	var body io.Reader
-	if payload != nil {
-		encoded, err := json.Marshal(payload)
-		if err != nil {
-			return nil, fmt.Errorf("encode request: %w", err)
-		}
-		body = bytes.NewReader(encoded)
-	}
-	req, err := http.NewRequest(method, c.baseURL+path, body)
-	if err != nil {
-		return nil, fmt.Errorf("create request: %w", err)
-	}
-	if payload != nil {
-		req.Header.Set("Content-Type", "application/json")
-	}
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("request failed: %w", err)
-	}
-	defer resp.Body.Close()
-	var result map[string]interface{}
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		return nil, fmt.Errorf("parse response: %w", err)
-	}
-	if resp.StatusCode >= 400 {
-		message, _ := result["message"].(string)
-		if message == "" {
-			message = resp.Status
-		}
-		return nil, fmt.Errorf("request failed: %s", message)
-	}
-	return result, nil
-}
-
-func (c *HTTPClient) ListUsers() (map[string]interface{}, error) {
-	return c.doJSON(http.MethodGet, "/api/auth/users/", nil)
-}
-
-func (c *HTTPClient) CreateUser(username, password, role string) (map[string]interface{}, error) {
-	return c.doJSON(http.MethodPost, "/api/auth/users/", map[string]string{"username": username, "password": password, "role": role})
-}
-
-func (c *HTTPClient) UpdateUserRole(username, role string) (map[string]interface{}, error) {
-	return c.doJSON(http.MethodPatch, "/api/auth/users/"+url.PathEscape(username)+"/role", map[string]string{"role": role})
-}
-
-func (c *HTTPClient) ResetUserPassword(username, password string) (map[string]interface{}, error) {
-	return c.doJSON(http.MethodPatch, "/api/auth/users/"+url.PathEscape(username)+"/reset-password", map[string]string{"newPassword": password})
-}
-
-func (c *HTTPClient) DeleteUser(username string) (map[string]interface{}, error) {
-	return c.doJSON(http.MethodDelete, "/api/auth/users/"+url.PathEscape(username), nil)
-}
-
-func (c *HTTPClient) ListRoles() (map[string]interface{}, error) {
-	return c.doJSON(http.MethodGet, "/api/auth/roles/", nil)
-}
-
-func (c *HTTPClient) CreateRole(roleName string, permissions []string) (map[string]interface{}, error) {
-	return c.doJSON(http.MethodPost, "/api/auth/roles/", map[string]interface{}{"roleName": roleName, "permissions": permissions})
-}
-
-func (c *HTTPClient) DeleteRole(roleName string) (map[string]interface{}, error) {
-	return c.doJSON(http.MethodDelete, "/api/auth/roles/"+url.PathEscape(roleName), nil)
-}
-
-func (c *HTTPClient) ListPermissions() (map[string]interface{}, error) {
-	return c.doJSON(http.MethodGet, "/api/auth/roles/permissions", nil)
-}
-
-func (c *HTTPClient) ChangeOwnPassword(currentPassword, newPassword string) (map[string]interface{}, error) {
-	return c.doJSON(http.MethodPatch, "/api/auth/change-password", map[string]string{"currentPassword": currentPassword, "newPassword": newPassword})
-}
-
-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/cli/pkg/protocol/auth.go

@@ -1,46 +0,0 @@
-package protocol
-
-import "fmt"
-
-type AuthResult struct {
-	Username          string `json:"username"`
-	Role              string `json:"role"`
-	MustChangePassword bool   `json:"mustChangePassword"`
-}
-
-func Authenticate(client *Client, username, password string) (*AuthResult, error) {
-	resp, err := client.Send("AUTHENTICATE", map[string]interface{}{
-		"username": username,
-		"password": password,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("authenticate: %w", err)
-	}
-
-	switch resp.StatusCode {
-	case 200:
-		data, ok := resp.Data.(map[string]interface{})
-		if !ok {
-			return nil, fmt.Errorf("unexpected auth response format")
-		}
-		result := &AuthResult{}
-		if v, ok := data["username"].(string); ok {
-			result.Username = v
-		}
-		if v, ok := data["role"].(string); ok {
-			result.Role = v
-		}
-		if v, ok := data["mustChangePassword"].(bool); ok {
-			result.MustChangePassword = v
-		}
-		return result, nil
-	case 401:
-		return nil, fmt.Errorf("authentication failed: invalid credentials")
-	case 403:
-		return nil, fmt.Errorf("authentication failed: password change required")
-	case 429:
-		return nil, fmt.Errorf("authentication failed: too many attempts, try again later")
-	default:
-		return nil, fmt.Errorf("authentication failed (status %d): %s", resp.StatusCode, resp.Error)
-	}
-}