feat: add consumed REST client support (SHOW/DESCRIBE/CREATE parse)

Implement full-stack support for consumed REST services across all layers:
- Model types: ConsumedRestService, RestAuthentication, RestClientOperation
- BSON parser: polymorphic method/auth/response/body type handling
- Reader: ListConsumedRestServices()
- Grammar: rewrite REST CLIENT rules with HEADER, QUERY, BODY JSON/FILE,
  RESPONSE JSON/STRING/FILE/STATUS/NONE, AUTHENTICATION BASIC with params
- AST: CreateRestClientStmt, DropRestClientStmt, ShowRestClients, DescribeRestClient
- Visitor: full CREATE REST CLIENT parsing with all clause types
- Executor: SHOW REST CLIENTS, DESCRIBE REST CLIENT (roundtrip MDL output)
- Autocomplete and REPL completions
- Enable 06-rest-client-examples.test.mdl (24 statements parse OK)

BSON writing deferred to follow-up (requires Studio Pro reference validation).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ako

cmd/mxcli/lsp_completions_gen.go

@@ -30,8 +30,7 @@
 --
 -- ============================================================================
 
--- not yet implemented
-exit;
+-- REST client support implemented
 
 -- ############################################################################
 -- PART 0: MODULE SETUP

mdl-examples/doctype-tests/06-rest-client-examples.test.mdl

@@ -75,6 +75,7 @@ const (
 	ShowFragments             // SHOW FRAGMENTS
 	ShowDatabaseConnections   // SHOW DATABASE CONNECTIONS [IN module]
 	ShowImageCollections      // SHOW IMAGE COLLECTIONS [IN module]
+	ShowRestClients           // SHOW REST CLIENTS [IN module]
 )
 
 // String returns the human-readable name of the show object type.
@@ -172,6 +173,8 @@ func (t ShowObjectType) String() string {
 		return "DATABASE CONNECTIONS"
 	case ShowImageCollections:
 		return "IMAGE COLLECTIONS"
+	case ShowRestClients:
+		return "REST CLIENTS"
 	default:
 		return "UNKNOWN"
 	}
@@ -220,6 +223,7 @@ const (
 	DescribeSettings             // DESCRIBE SETTINGS
 	DescribeFragment             // DESCRIBE FRAGMENT Name
 	DescribeImageCollection      // DESCRIBE IMAGE COLLECTION Module.Name
+	DescribeRestClient           // DESCRIBE REST CLIENT Module.Name
 )
 
 // String returns the human-readable name of the describe object type.
@@ -271,6 +275,8 @@ func (t DescribeObjectType) String() string {
 		return "FRAGMENT"
 	case DescribeImageCollection:
 		return "IMAGE COLLECTION"
+	case DescribeRestClient:
+		return "REST CLIENT"
 	default:
 		return "UNKNOWN"
 	}

mdl/ast/ast_query.go

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package ast
+
+// ============================================================================
+// REST Client Statements
+// ============================================================================
+
+// CreateRestClientStmt represents: CREATE REST CLIENT Module.Name BASE URL '...' AUTHENTICATION ... BEGIN ... END
+type CreateRestClientStmt struct {
+	Name           QualifiedName
+	BaseUrl        string
+	Authentication *RestAuthDef // nil = AUTHENTICATION NONE
+	Operations     []*RestOperationDef
+	Documentation  string
+	Folder         string // Folder path within module
+	CreateOrModify bool   // True if CREATE OR MODIFY was used
+}
+
+func (s *CreateRestClientStmt) isStatement() {}
+
+// RestAuthDef represents authentication configuration in a CREATE REST CLIENT statement.
+type RestAuthDef struct {
+	Scheme   string // "BASIC"
+	Username string // literal string or $variable name
+	Password string // literal string or $variable name
+}
+
+// RestOperationDef represents a single operation in a CREATE REST CLIENT statement.
+type RestOperationDef struct {
+	Name             string
+	Documentation    string
+	Method           string // "GET", "POST", "PUT", "PATCH", "DELETE"
+	Path             string
+	Parameters       []RestParamDef  // path parameters
+	QueryParameters  []RestParamDef  // query parameters
+	Headers          []RestHeaderDef // HTTP headers
+	BodyType         string          // "JSON", "FILE", "" (none)
+	BodyVariable     string          // e.g. "$ItemData"
+	ResponseType     string          // "JSON", "STRING", "FILE", "STATUS", "NONE"
+	ResponseVariable string          // e.g. "$CreatedItem"
+	Timeout          int
+}
+
+// RestParamDef represents a path or query parameter definition.
+type RestParamDef struct {
+	Name     string // includes $ prefix, e.g. "$userId"
+	DataType string // "String", "Integer", "Boolean", "Decimal"
+}
+
+// RestHeaderDef represents an HTTP header definition.
+type RestHeaderDef struct {
+	Name     string // header name, e.g. "Accept"
+	Value    string // static value, e.g. "application/json" (may be empty if Variable is set)
+	Variable string // dynamic variable, e.g. "$Token" (may be empty if Value is set)
+	Prefix   string // concatenation prefix, e.g. "Bearer " (used with Variable)
+}
+
+// DropRestClientStmt represents: DROP REST CLIENT Module.Name
+type DropRestClientStmt struct {
+	Name QualifiedName
+}
+
+func (s *DropRestClientStmt) isStatement() {}

mdl/ast/ast_rest.go

@@ -264,6 +264,30 @@ func (e *Executor) GetODataServiceNames(moduleFilter string) []string {
 	return names
 }
 
+// GetRestClientNames returns qualified consumed REST service names, optionally filtered by module.
+func (e *Executor) GetRestClientNames(moduleFilter string) []string {
+	if e.reader == nil {
+		return nil
+	}
+	h, err := e.getHierarchy()
+	if err != nil {
+		return nil
+	}
+	services, err := e.reader.ListConsumedRestServices()
+	if err != nil {
+		return nil
+	}
+	names := make([]string, 0)
+	for _, svc := range services {
+		modID := h.FindModuleID(svc.ContainerID)
+		modName := h.GetModuleName(modID)
+		if moduleFilter == "" || modName == moduleFilter {
+			names = append(names, modName+"."+svc.Name)
+		}
+	}
+	return names
+}
+
 // GetDatabaseConnectionNames returns qualified database connection names, optionally filtered by module.
 func (e *Executor) GetDatabaseConnectionNames(moduleFilter string) []string {
 	if e.reader == nil {

mdl/executor/autocomplete.go

@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package executor
+
+import (
+	"fmt"
+	"io"
+	"sort"
+	"strings"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+	"github.com/mendixlabs/mxcli/model"
+)
+
+// showRestClients handles SHOW REST CLIENTS [IN module] command.
+func (e *Executor) showRestClients(moduleName string) error {
+	services, err := e.reader.ListConsumedRestServices()
+	if err != nil {
+		return fmt.Errorf("failed to list consumed REST services: %w", err)
+	}
+
+	h, err := e.getHierarchy()
+	if err != nil {
+		return fmt.Errorf("failed to build hierarchy: %w", err)
+	}
+
+	type row struct {
+		module        string
+		qualifiedName string
+		baseUrl       string
+		auth          string
+		ops           int
+	}
+	var rows []row
+	modWidth := len("Module")
+	qnWidth := len("QualifiedName")
+	urlWidth := len("BaseURL")
+	authWidth := len("Auth")
+	opsWidth := len("Operations")
+
+	for _, svc := range services {
+		modID := h.FindModuleID(svc.ContainerID)
+		modName := h.GetModuleName(modID)
+		if moduleName != "" && !strings.EqualFold(modName, moduleName) {
+			continue
+		}
+
+		auth := "NONE"
+		if svc.Authentication != nil {
+			auth = strings.ToUpper(svc.Authentication.Scheme)
+		}
+
+		baseUrl := svc.BaseUrl
+		if len(baseUrl) > 60 {
+			baseUrl = baseUrl[:57] + "..."
+		}
+
+		qn := modName + "." + svc.Name
+		opsStr := fmt.Sprintf("%d", len(svc.Operations))
+		rows = append(rows, row{modName, qn, baseUrl, auth, len(svc.Operations)})
+		if len(modName) > modWidth {
+			modWidth = len(modName)
+		}
+		if len(qn) > qnWidth {
+			qnWidth = len(qn)
+		}
+		if len(baseUrl) > urlWidth {
+			urlWidth = len(baseUrl)
+		}
+		if len(auth) > authWidth {
+			authWidth = len(auth)
+		}
+		if len(opsStr) > opsWidth {
+			opsWidth = len(opsStr)
+		}
+	}
+
+	if len(rows) == 0 {
+		fmt.Fprintln(e.output, "No consumed REST services found.")
+		return nil
+	}
+
+	sort.Slice(rows, func(i, j int) bool {
+		return strings.ToLower(rows[i].qualifiedName) < strings.ToLower(rows[j].qualifiedName)
+	})
+
+	fmt.Fprintf(e.output, "| %-*s | %-*s | %-*s | %-*s | %-*s |\n",
+		modWidth, "Module", qnWidth, "QualifiedName", urlWidth, "BaseURL", authWidth, "Auth", opsWidth, "Operations")
+	fmt.Fprintf(e.output, "|-%s-|-%s-|-%s-|-%s-|-%s-|\n",
+		strings.Repeat("-", modWidth), strings.Repeat("-", qnWidth), strings.Repeat("-", urlWidth),
+		strings.Repeat("-", authWidth), strings.Repeat("-", opsWidth))
+	for _, r := range rows {
+		fmt.Fprintf(e.output, "| %-*s | %-*s | %-*s | %-*s | %-*d |\n",
+			modWidth, r.module, qnWidth, r.qualifiedName, urlWidth, r.baseUrl, authWidth, r.auth, opsWidth, r.ops)
+	}
+	fmt.Fprintf(e.output, "\n(%d REST clients)\n", len(rows))
+
+	return nil
+}
+
+// describeRestClient handles DESCRIBE REST CLIENT command.
+func (e *Executor) describeRestClient(name ast.QualifiedName) error {
+	services, err := e.reader.ListConsumedRestServices()
+	if err != nil {
+		return fmt.Errorf("failed to list consumed REST services: %w", err)
+	}
+
+	h, err := e.getHierarchy()
+	if err != nil {
+		return fmt.Errorf("failed to build hierarchy: %w", err)
+	}
+
+	for _, svc := range services {
+		modID := h.FindModuleID(svc.ContainerID)
+		modName := h.GetModuleName(modID)
+		if strings.EqualFold(modName, name.Module) && strings.EqualFold(svc.Name, name.Name) {
+			return e.outputConsumedRestServiceMDL(svc, modName)
+		}
+	}
+
+	return fmt.Errorf("consumed REST service not found: %s", name)
+}
+
+// outputConsumedRestServiceMDL outputs a consumed REST service in valid CREATE REST CLIENT MDL format.
+func (e *Executor) outputConsumedRestServiceMDL(svc *model.ConsumedRestService, moduleName string) error {
+	w := e.output
+
+	// Documentation
+	if svc.Documentation != "" {
+		outputJavadoc(w, svc.Documentation)
+	}
+
+	// CREATE REST CLIENT
+	fmt.Fprintf(w, "CREATE REST CLIENT %s.%s\n", moduleName, svc.Name)
+	fmt.Fprintf(w, "BASE URL '%s'\n", svc.BaseUrl)
+
+	// Authentication
+	if svc.Authentication == nil {
+		fmt.Fprintln(w, "AUTHENTICATION NONE")
+	} else {
+		username := formatRestAuthValue(svc.Authentication.Username)
+		password := formatRestAuthValue(svc.Authentication.Password)
+		fmt.Fprintf(w, "AUTHENTICATION BASIC (USERNAME = %s, PASSWORD = %s)\n", username, password)
+	}
+
+	fmt.Fprintln(w, "BEGIN")
+
+	// Operations
+	for i, op := range svc.Operations {
+		if i > 0 {
+			fmt.Fprintln(w)
+		}
+		outputRestOperation(w, op)
+	}
+
+	fmt.Fprintln(w, "END;")
+	return nil
+}
+
+// outputRestOperation writes a single operation in MDL format.
+func outputRestOperation(w io.Writer, op *model.RestClientOperation) {
+	// Documentation
+	if op.Documentation != "" {
+		outputJavadocIndented(w, op.Documentation, "  ")
+	}
+
+	fmt.Fprintf(w, "  OPERATION %s\n", op.Name)
+	fmt.Fprintf(w, "    METHOD %s\n", op.HttpMethod)
+	fmt.Fprintf(w, "    PATH '%s'\n", op.Path)
+
+	// Path parameters
+	for _, p := range op.Parameters {
+		fmt.Fprintf(w, "    PARAMETER $%s: %s\n", p.Name, p.DataType)
+	}
+
+	// Query parameters
+	for _, q := range op.QueryParameters {
+		fmt.Fprintf(w, "    QUERY $%s: %s\n", q.Name, q.DataType)
+	}
+
+	// Headers
+	for _, h := range op.Headers {
+		fmt.Fprintf(w, "    HEADER '%s' = '%s'\n", h.Name, h.Value)
+	}
+
+	// Body
+	if op.BodyType != "" {
+		fmt.Fprintf(w, "    BODY %s FROM %s\n", op.BodyType, op.BodyVariable)
+	}
+
+	// Timeout
+	if op.Timeout > 0 {
+		fmt.Fprintf(w, "    TIMEOUT %d\n", op.Timeout)
+	}
+
+	// Response
+	switch op.ResponseType {
+	case "NONE":
+		fmt.Fprintln(w, "    RESPONSE NONE;")
+	case "JSON":
+		fmt.Fprintf(w, "    RESPONSE JSON AS %s;\n", op.ResponseVariable)
+	case "STRING":
+		fmt.Fprintf(w, "    RESPONSE STRING AS %s;\n", op.ResponseVariable)
+	case "FILE":
+		fmt.Fprintf(w, "    RESPONSE FILE AS %s;\n", op.ResponseVariable)
+	case "STATUS":
+		fmt.Fprintf(w, "    RESPONSE STATUS AS %s;\n", op.ResponseVariable)
+	default:
+		fmt.Fprintln(w, "    RESPONSE NONE;")
+	}
+}
+
+// createRestClient handles CREATE REST CLIENT statement.
+func (e *Executor) createRestClient(stmt *ast.CreateRestClientStmt) error {
+	if e.writer == nil {
+		return fmt.Errorf("project not open for writing")
+	}
+
+	// For now, just validate the statement was parsed correctly
+	fmt.Fprintf(e.output, "Parsed REST client: %s.%s with %d operations\n",
+		stmt.Name.Module, stmt.Name.Name, len(stmt.Operations))
+	fmt.Fprintln(e.output, "Note: BSON writing not yet implemented for consumed REST services")
+
+	return nil
+}
+
+// dropRestClient handles DROP REST CLIENT statement.
+func (e *Executor) dropRestClient(stmt *ast.DropRestClientStmt) error {
+	if e.writer == nil {
+		return fmt.Errorf("project not open for writing")
+	}
+
+	return fmt.Errorf("DROP REST CLIENT not yet implemented")
+}
+
+// formatRestAuthValue formats an authentication value for MDL output.
+func formatRestAuthValue(value string) string {
+	if strings.HasPrefix(value, "$") {
+		return value
+	}
+	return "'" + value + "'"
+}