Fix action ergonomics and add storage commands

Author: artpar

client/asset.go

@@ -0,0 +1,67 @@
+package client
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/url"
+)
+
+// UploadAssetStream streams a file to Daptin's asset upload endpoint.
+func (e *ExtendedClient) UploadAssetStream(entityName, referenceID, columnName, filename, contentType string, size int64, body io.Reader) (map[string]interface{}, error) {
+	u := fmt.Sprintf("%s/asset/%s/%s/%s/upload?operation=stream&filename=%s",
+		e.Endpoint,
+		url.PathEscape(entityName),
+		url.PathEscape(referenceID),
+		url.PathEscape(columnName),
+		url.QueryEscape(filename),
+	)
+
+	resp, err := e.nextRequest().
+		SetHeader("Content-Type", contentType).
+		SetHeader("X-File-Type", contentType).
+		SetHeader("X-File-Size", fmt.Sprintf("%d", size)).
+		SetBody(body).
+		Post(u)
+	if err := e.checkResponse(resp, err); err != nil {
+		return nil, err
+	}
+
+	var data map[string]interface{}
+	if err := json.Unmarshal(resp.Body(), &data); err != nil {
+		return nil, fmt.Errorf("parse upload response: %w", err)
+	}
+	return data, nil
+}
+
+// CompleteAssetUpload finalizes an asset upload and updates the row's file column.
+func (e *ExtendedClient) CompleteAssetUpload(entityName, referenceID, columnName, filename, uploadID, contentType string, size int64) (map[string]interface{}, error) {
+	u := fmt.Sprintf("%s/asset/%s/%s/%s/upload?operation=complete&upload_id=%s&filename=%s",
+		e.Endpoint,
+		url.PathEscape(entityName),
+		url.PathEscape(referenceID),
+		url.PathEscape(columnName),
+		url.QueryEscape(uploadID),
+		url.QueryEscape(filename),
+	)
+
+	body := map[string]interface{}{
+		"fileName": filename,
+		"size":     size,
+		"type":     contentType,
+	}
+	resp, err := e.nextRequest().
+		SetHeader("X-File-Type", contentType).
+		SetHeader("X-File-Size", fmt.Sprintf("%d", size)).
+		SetBody(body).
+		Post(u)
+	if err := e.checkResponse(resp, err); err != nil {
+		return nil, err
+	}
+
+	var data map[string]interface{}
+	if err := json.Unmarshal(resp.Body(), &data); err != nil {
+		return nil, fmt.Errorf("parse complete response: %w", err)
+	}
+	return data, nil
+}

cmd/action.go

@@ -9,6 +9,7 @@ import (
 	"syscall"
 
 	"github.com/daptin/daptin-cli/client"
+	"github.com/daptin/daptin-cli/render"
 	daptinClient "github.com/daptin/daptin-go-client"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/term"
@@ -48,7 +49,7 @@ func executeCommand(appCtx *AppContext) *cli.Command {
 				slog.Debug("interactive mode enabled, fetching schema")
 				schema, schemaErr := fetchActionSchemaFromServer(appCtx, entityName, actionName)
 				if schemaErr == nil {
-					prompts := MissingFields(schema, attrs)
+					prompts := MissingFields(schema.InFields, attrs)
 					filled, err := promptUser(prompts)
 					if err != nil {
 						return err
@@ -70,6 +71,9 @@ func executeCommand(appCtx *AppContext) *cli.Command {
 
 			// Pure: compute effects from responses
 			effects := ProcessResponses(responses)
+			if len(effects) == 0 {
+				effects = append(effects, BuildActionSuccessEffect(entityName, actionName, c.String("reference-id")))
+			}
 
 			// IO boundary: apply effects
 			return applyEffects(effects, appCtx)
@@ -103,50 +107,66 @@ func applyEffects(effects []ResponseEffect, appCtx *AppContext) error {
 			if err := appCtx.Renderer.RenderObject(e.Data); err != nil {
 				return err
 			}
+		case "success":
+			if appCtx.Quiet {
+				continue
+			}
+			if _, ok := appCtx.Renderer.(*render.JsonRenderer); ok {
+				if err := appCtx.Renderer.RenderObject(e.Data); err != nil {
+					return err
+				}
+				continue
+			}
+			fmt.Fprintln(os.Stdout, e.Message)
 		}
 	}
 	return nil
 }
 
 // fetchActionSchemaFromServer fetches InFields for an action via the API.
 // IO boundary: makes HTTP calls, then delegates to pure functions.
-func fetchActionSchemaFromServer(appCtx *AppContext, entityName, actionName string) ([]map[string]interface{}, error) {
+func fetchActionSchemaFromServer(appCtx *AppContext, entityName, actionName string) (ActionSchema, error) {
 	slog.Debug("fetching action schema", "entity", entityName, "action", actionName)
 	worlds, err := appCtx.Client.FindAll("world", daptinClient.DaptinQueryParameters{
 		"page[size]": 500,
 	})
 	if err != nil {
-		return nil, err
+		return ActionSchema{}, err
 	}
 
 	worldAttrs := client.MapArray(worlds, "attributes")
 	worldRefId := FindWorldRefId(worldAttrs, entityName)
 	if worldRefId == "" {
-		return nil, fmt.Errorf("entity %q not found", entityName)
+		return ActionSchema{}, fmt.Errorf("entity %q not found", entityName)
 	}
 
 	actions, err := appCtx.Client.FindAll("action", daptinClient.DaptinQueryParameters{
 		"page[size]": 500,
 	})
 	if err != nil {
-		return nil, err
+		return ActionSchema{}, err
 	}
 
 	actionAttrs := client.MapArray(actions, "attributes")
-	actionRefId := FindActionRefId(actionAttrs, worldRefId, actionName)
-	if actionRefId == "" {
-		return nil, fmt.Errorf("action %q not found on %q", actionName, entityName)
+	schema := FindActionMetadata(actionAttrs, worldRefId, entityName, actionName)
+	if schema.ReferenceID == "" {
+		return ActionSchema{}, fmt.Errorf("action %q not found on %q", actionName, entityName)
 	}
 
 	// Execute get_action_schema to retrieve the schema (base64 encoded)
 	responses, err := appCtx.Client.Execute("get_action_schema", "action", daptinClient.JsonApiObject{
-		"action_id": actionRefId,
+		"action_id": schema.ReferenceID,
 	})
 	if err != nil {
-		return nil, err
+		return ActionSchema{}, err
 	}
 
-	return DecodeActionSchemaResponse(responses)
+	inFields, err := DecodeActionSchemaResponse(responses)
+	if err != nil {
+		return ActionSchema{}, err
+	}
+	schema.InFields = inFields
+	return schema, nil
 }
 
 // promptUser performs IO to collect values for missing fields.

cmd/action_response.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"log/slog"
+	"strings"
 
 	daptinClient "github.com/daptin/daptin-go-client"
 )
@@ -24,6 +25,14 @@ type ResponseEffect struct {
 	Data map[string]interface{}
 }
 
+type ActionSchema struct {
+	EntityName       string
+	ActionName       string
+	ReferenceID      string
+	InstanceOptional bool
+	InFields         []map[string]interface{}
+}
+
 // ProcessResponses converts raw action responses into a list of effects.
 // Pure function: values in, values out. No IO.
 func ProcessResponses(responses []daptinClient.DaptinActionResponse) []ResponseEffect {
@@ -59,6 +68,20 @@ func ProcessResponses(responses []daptinClient.DaptinActionResponse) []ResponseE
 	return effects
 }
 
+func BuildActionSuccessEffect(entityName, actionName, referenceID string) ResponseEffect {
+	message := fmt.Sprintf("OK: %s.%s executed", entityName, actionName)
+	data := map[string]interface{}{
+		"ok":     true,
+		"entity": entityName,
+		"action": actionName,
+	}
+	if referenceID != "" {
+		message = fmt.Sprintf("%s for %s", message, referenceID)
+		data["reference_id"] = referenceID
+	}
+	return ResponseEffect{Type: "success", Message: message, Data: data}
+}
+
 // FieldPrompt describes a field that needs user input.
 // Pure value — computed from schema + already-provided attrs.
 type FieldPrompt struct {
@@ -136,14 +159,25 @@ func FindWorldRefId(worldAttrs []map[string]interface{}, entityName string) stri
 // FindActionRefId finds an action's reference_id by name and world_id from pre-fetched action attributes.
 // Pure function.
 func FindActionRefId(actionAttrs []map[string]interface{}, worldRefId, actionName string) string {
+	meta := FindActionMetadata(actionAttrs, worldRefId, "", actionName)
+	return meta.ReferenceID
+}
+
+func FindActionMetadata(actionAttrs []map[string]interface{}, worldRefId, entityName, actionName string) ActionSchema {
 	for _, a := range actionAttrs {
 		if a["action_name"] == actionName && a["world_id"] == worldRefId {
-			if refId, ok := a["reference_id"].(string); ok {
-				return refId
+			meta := ActionSchema{
+				EntityName:       entityName,
+				ActionName:       actionName,
+				InstanceOptional: boolValue(a["instance_optional"]),
 			}
+			if refID, ok := a["reference_id"].(string); ok {
+				meta.ReferenceID = refID
+			}
+			return meta
 		}
 	}
-	return ""
+	return ActionSchema{}
 }
 
 // DecodeActionSchemaResponse extracts and parses InFields from a get_action_schema response.
@@ -166,3 +200,14 @@ func DecodeActionSchemaResponse(responses []daptinClient.DaptinActionResponse) (
 	}
 	return nil, fmt.Errorf("no schema in response")
 }
+
+func boolValue(value interface{}) bool {
+	switch v := value.(type) {
+	case bool:
+		return v
+	case string:
+		return strings.EqualFold(v, "true")
+	default:
+		return false
+	}
+}

cmd/action_response_test.go

@@ -189,6 +189,23 @@ func TestProcessResponses_StoreSetNonToken(t *testing.T) {
 	}
 }
 
+func TestBuildActionSuccessEffect(t *testing.T) {
+	effect := BuildActionSuccessEffect("integration", "install_integration", "ref-123")
+
+	if effect.Type != "success" {
+		t.Fatalf("expected success effect, got %s", effect.Type)
+	}
+	if effect.Message != "OK: integration.install_integration executed for ref-123" {
+		t.Errorf("unexpected message: %s", effect.Message)
+	}
+	if effect.Data["ok"] != true {
+		t.Errorf("expected ok=true, got %v", effect.Data["ok"])
+	}
+	if effect.Data["reference_id"] != "ref-123" {
+		t.Errorf("expected reference_id ref-123, got %v", effect.Data["reference_id"])
+	}
+}
+
 // --- MissingFields tests ---
 
 func TestMissingFields_AllProvided(t *testing.T) {
@@ -360,6 +377,39 @@ func TestFindActionRefId_WrongWorld(t *testing.T) {
 	}
 }
 
+func TestFindActionMetadata(t *testing.T) {
+	actions := []map[string]interface{}{
+		{"action_name": "install_integration", "world_id": "uuid-integration", "reference_id": "ref-install", "instance_optional": false},
+	}
+
+	meta := FindActionMetadata(actions, "uuid-integration", "integration", "install_integration")
+
+	if meta.ReferenceID != "ref-install" {
+		t.Errorf("expected ref-install, got %s", meta.ReferenceID)
+	}
+	if meta.EntityName != "integration" {
+		t.Errorf("expected integration, got %s", meta.EntityName)
+	}
+	if meta.ActionName != "install_integration" {
+		t.Errorf("expected install_integration, got %s", meta.ActionName)
+	}
+	if meta.InstanceOptional {
+		t.Error("expected instance_optional false")
+	}
+}
+
+func TestFindActionMetadata_StringBool(t *testing.T) {
+	actions := []map[string]interface{}{
+		{"action_name": "signin", "world_id": "uuid-user", "reference_id": "ref-signin", "instance_optional": "true"},
+	}
+
+	meta := FindActionMetadata(actions, "uuid-user", "user_account", "signin")
+
+	if !meta.InstanceOptional {
+		t.Error("expected string true to parse as true")
+	}
+}
+
 func TestDecodeActionSchemaResponse_Valid(t *testing.T) {
 	// Base64 of: {"InFields":[{"ColumnName":"email","ColumnType":"email"}]}
 	schema := `{"InFields":[{"ColumnName":"email","ColumnType":"email"}]}`

cmd/app.go

@@ -121,6 +121,8 @@ func NewApp(cfg *config.Config, version string) *cli.App {
 			unrelateCommand(appCtx),
 			describeCommand(appCtx),
 			executeCommand(appCtx),
+			storageCommand(appCtx),
+			assetCommand(appCtx),
 			permissionCommand(appCtx),
 			wsCommand(appCtx),
 		},