feat: add CREATE/DROP NANOFLOW support — grammar, AST, visitor, executor

Author: retran

mdl/ast/ast_microflow.go

@@ -65,6 +65,28 @@ type DropMicroflowStmt struct {
 
 func (s *DropMicroflowStmt) isStatement() {}
 
+// CreateNanoflowStmt represents: CREATE NANOFLOW Module.Name (params) RETURNS type BEGIN body END
+type CreateNanoflowStmt struct {
+	Name           QualifiedName
+	Parameters     []MicroflowParam
+	ReturnType     *MicroflowReturnType
+	Body           []MicroflowStatement
+	Documentation  string
+	Comment        string
+	Folder         string // Folder path within module
+	CreateOrModify bool
+	Excluded       bool // @excluded — document excluded from project
+}
+
+func (s *CreateNanoflowStmt) isStatement() {}
+
+// DropNanoflowStmt represents: DROP NANOFLOW Module.Name
+type DropNanoflowStmt struct {
+	Name QualifiedName
+}
+
+func (s *DropNanoflowStmt) isStatement() {}
+
 // ============================================================================
 // Microflow Body Statements
 // ============================================================================

mdl/executor/cmd_nanoflows_create.go

@@ -0,0 +1,225 @@
+// SPDX-License-Identifier: Apache-2.0
+
+// Package executor - CREATE NANOFLOW command
+package executor
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+	mdlerrors "github.com/mendixlabs/mxcli/mdl/errors"
+	"github.com/mendixlabs/mxcli/mdl/types"
+	"github.com/mendixlabs/mxcli/model"
+	"github.com/mendixlabs/mxcli/sdk/microflows"
+)
+
+// execCreateNanoflow handles CREATE NANOFLOW statements.
+func execCreateNanoflow(ctx *ExecContext, s *ast.CreateNanoflowStmt) error {
+	if !ctx.ConnectedForWrite() {
+		return mdlerrors.NewNotConnectedWrite()
+	}
+
+	// Find or auto-create module
+	module, err := findOrCreateModule(ctx, s.Name.Module)
+	if err != nil {
+		return err
+	}
+
+	// Resolve folder if specified
+	containerID := module.ID
+	if s.Folder != "" {
+		folderID, err := resolveFolder(ctx, module.ID, s.Folder)
+		if err != nil {
+			return mdlerrors.NewBackend("resolve folder "+s.Folder, err)
+		}
+		containerID = folderID
+	}
+
+	// Check if nanoflow with same name already exists in this module
+	var existingID model.ID
+	var existingContainerID model.ID
+	existingNanoflows, err := ctx.Backend.ListNanoflows()
+	if err != nil {
+		return mdlerrors.NewBackend("check existing nanoflows", err)
+	}
+	for _, existing := range existingNanoflows {
+		if existing.Name == s.Name.Name && getModuleID(ctx, existing.ContainerID) == module.ID {
+			if !s.CreateOrModify {
+				return mdlerrors.NewAlreadyExistsMsg("nanoflow", s.Name.Module+"."+s.Name.Name, "nanoflow '"+s.Name.Module+"."+s.Name.Name+"' already exists (use create or replace to overwrite)")
+			}
+			existingID = existing.ID
+			existingContainerID = existing.ContainerID
+			break
+		}
+	}
+
+	// For CREATE OR REPLACE/MODIFY, reuse the existing ID to preserve references
+	qualifiedName := s.Name.Module + "." + s.Name.Name
+	nanoflowID := model.ID(types.GenerateID())
+	if existingID != "" {
+		nanoflowID = existingID
+		if s.Folder == "" {
+			containerID = existingContainerID
+		}
+	} else if dropped := consumeDroppedNanoflow(ctx, qualifiedName); dropped != nil {
+		nanoflowID = dropped.ID
+		if s.Folder == "" && dropped.ContainerID != "" {
+			containerID = dropped.ContainerID
+		}
+	}
+
+	// Build the nanoflow
+	nf := &microflows.Nanoflow{
+		BaseElement: model.BaseElement{
+			ID: nanoflowID,
+		},
+		ContainerID:   containerID,
+		Name:          s.Name.Name,
+		Documentation: s.Documentation,
+		MarkAsUsed:    false,
+		Excluded:      s.Excluded,
+	}
+
+	// Build entity resolver function for parameter/return types
+	entityResolver := func(qn ast.QualifiedName) model.ID {
+		dms, err := ctx.Backend.ListDomainModels()
+		if err != nil {
+			return ""
+		}
+		modules, _ := ctx.Backend.ListModules()
+		moduleNames := make(map[model.ID]string)
+		for _, m := range modules {
+			moduleNames[m.ID] = m.Name
+		}
+		for _, dm := range dms {
+			modName := moduleNames[dm.ContainerID]
+			if modName != qn.Module {
+				continue
+			}
+			for _, ent := range dm.Entities {
+				if ent.Name == qn.Name {
+					return ent.ID
+				}
+			}
+		}
+		return ""
+	}
+
+	// Validate and add parameters
+	for _, p := range s.Parameters {
+		if p.Type.EntityRef != nil && !isBuiltinModuleEntity(p.Type.EntityRef.Module) {
+			entityID := entityResolver(*p.Type.EntityRef)
+			if entityID == "" {
+				return mdlerrors.NewNotFoundMsg("entity", p.Type.EntityRef.Module+"."+p.Type.EntityRef.Name,
+					fmt.Sprintf("entity '%s.%s' not found for parameter '%s'", p.Type.EntityRef.Module, p.Type.EntityRef.Name, p.Name))
+			}
+		}
+		if p.Type.Kind == ast.TypeEnumeration && p.Type.EnumRef != nil {
+			if found := findEnumeration(ctx, p.Type.EnumRef.Module, p.Type.EnumRef.Name); found == nil {
+				return mdlerrors.NewNotFoundMsg("enumeration", p.Type.EnumRef.Module+"."+p.Type.EnumRef.Name,
+					fmt.Sprintf("enumeration '%s.%s' not found for parameter '%s'", p.Type.EnumRef.Module, p.Type.EnumRef.Name, p.Name))
+			}
+		}
+		param := &microflows.MicroflowParameter{
+			BaseElement: model.BaseElement{
+				ID: model.ID(types.GenerateID()),
+			},
+			ContainerID: nf.ID,
+			Name:        p.Name,
+			Type:        convertASTToMicroflowDataType(p.Type, entityResolver),
+		}
+		nf.Parameters = append(nf.Parameters, param)
+	}
+
+	// Validate and set return type
+	if s.ReturnType != nil {
+		if s.ReturnType.Type.EntityRef != nil && !isBuiltinModuleEntity(s.ReturnType.Type.EntityRef.Module) {
+			entityID := entityResolver(*s.ReturnType.Type.EntityRef)
+			if entityID == "" {
+				return mdlerrors.NewNotFoundMsg("entity", s.ReturnType.Type.EntityRef.Module+"."+s.ReturnType.Type.EntityRef.Name,
+					fmt.Sprintf("entity '%s.%s' not found for return type", s.ReturnType.Type.EntityRef.Module, s.ReturnType.Type.EntityRef.Name))
+			}
+		}
+		if s.ReturnType.Type.Kind == ast.TypeEnumeration && s.ReturnType.Type.EnumRef != nil {
+			if found := findEnumeration(ctx, s.ReturnType.Type.EnumRef.Module, s.ReturnType.Type.EnumRef.Name); found == nil {
+				return mdlerrors.NewNotFoundMsg("enumeration", s.ReturnType.Type.EnumRef.Module+"."+s.ReturnType.Type.EnumRef.Name,
+					fmt.Sprintf("enumeration '%s.%s' not found for return type", s.ReturnType.Type.EnumRef.Module, s.ReturnType.Type.EnumRef.Name))
+			}
+		}
+		nf.ReturnType = convertASTToMicroflowDataType(s.ReturnType.Type, entityResolver)
+	} else {
+		nf.ReturnType = &microflows.VoidType{}
+	}
+
+	// Validate nanoflow-specific constraints before building the flow graph
+	qualName := s.Name.Module + "." + s.Name.Name
+	if errMsg := validateNanoflow(qualName, s.Body, s.ReturnType); errMsg != "" {
+		return fmt.Errorf("%s", errMsg)
+	}
+
+	// Build flow graph from body statements
+	varTypes := make(map[string]string)
+	declaredVars := make(map[string]string)
+
+	for _, p := range s.Parameters {
+		if p.Type.EntityRef != nil {
+			entityQN := p.Type.EntityRef.Module + "." + p.Type.EntityRef.Name
+			if p.Type.Kind == ast.TypeListOf {
+				varTypes[p.Name] = "List of " + entityQN
+			} else {
+				varTypes[p.Name] = entityQN
+			}
+		} else {
+			declaredVars[p.Name] = p.Type.Kind.String()
+		}
+	}
+
+	hierarchy, _ := getHierarchy(ctx)
+	restServices, _ := loadRestServices(ctx)
+
+	builder := &flowBuilder{
+		posX:         200,
+		posY:         200,
+		baseY:        200,
+		spacing:      HorizontalSpacing,
+		varTypes:     varTypes,
+		declaredVars: declaredVars,
+		measurer:     &layoutMeasurer{varTypes: varTypes},
+		backend:      ctx.Backend,
+		hierarchy:    hierarchy,
+		restServices: restServices,
+	}
+
+	nf.ObjectCollection = builder.buildFlowGraph(s.Body, s.ReturnType)
+
+	// Check for validation errors
+	if errors := builder.GetErrors(); len(errors) > 0 {
+		var errMsg strings.Builder
+		errMsg.WriteString(fmt.Sprintf("nanoflow '%s.%s' has validation errors:\n", s.Name.Module, s.Name.Name))
+		for _, err := range errors {
+			errMsg.WriteString(fmt.Sprintf("  - %s\n", err))
+		}
+		return fmt.Errorf("%s", errMsg.String())
+	}
+
+	// Create or update the nanoflow
+	if existingID != "" {
+		if err := ctx.Backend.UpdateNanoflow(nf); err != nil {
+			return mdlerrors.NewBackend("update nanoflow", err)
+		}
+		fmt.Fprintf(ctx.Output, "Replaced nanoflow: %s.%s\n", s.Name.Module, s.Name.Name)
+	} else {
+		if err := ctx.Backend.CreateNanoflow(nf); err != nil {
+			return mdlerrors.NewBackend("create nanoflow", err)
+		}
+		fmt.Fprintf(ctx.Output, "Created nanoflow: %s.%s\n", s.Name.Module, s.Name.Name)
+	}
+
+	// Track the created nanoflow
+	returnEntityName := extractEntityFromReturnType(nf.ReturnType)
+	ctx.trackCreatedNanoflow(s.Name.Module, s.Name.Name, nf.ID, containerID, returnEntityName)
+
+	invalidateHierarchy(ctx)
+	return nil
+}

mdl/executor/cmd_nanoflows_drop.go

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+
+// Package executor - DROP NANOFLOW command
+package executor
+
+import (
+	"fmt"
+
+	"github.com/mendixlabs/mxcli/mdl/ast"
+	mdlerrors "github.com/mendixlabs/mxcli/mdl/errors"
+)
+
+// execDropNanoflow handles DROP NANOFLOW statements.
+func execDropNanoflow(ctx *ExecContext, s *ast.DropNanoflowStmt) error {
+	if !ctx.ConnectedForWrite() {
+		return mdlerrors.NewNotConnectedWrite()
+	}
+
+	// Get hierarchy for module/folder resolution
+	h, err := getHierarchy(ctx)
+	if err != nil {
+		return mdlerrors.NewBackend("build hierarchy", err)
+	}
+
+	// Find and delete the nanoflow
+	nfs, err := ctx.Backend.ListNanoflows()
+	if err != nil {
+		return mdlerrors.NewBackend("list nanoflows", err)
+	}
+
+	for _, nf := range nfs {
+		modID := h.FindModuleID(nf.ContainerID)
+		modName := h.GetModuleName(modID)
+		if modName == s.Name.Module && nf.Name == s.Name.Name {
+			qualifiedName := s.Name.Module + "." + s.Name.Name
+			rememberDroppedNanoflow(ctx, qualifiedName, nf.ID, nf.ContainerID)
+			if err := ctx.Backend.DeleteNanoflow(nf.ID); err != nil {
+				return mdlerrors.NewBackend("delete nanoflow", err)
+			}
+			// Clear executor-level caches
+			if ctx.Cache != nil && ctx.Cache.createdNanoflows != nil {
+				delete(ctx.Cache.createdNanoflows, qualifiedName)
+			}
+			invalidateHierarchy(ctx)
+			fmt.Fprintf(ctx.Output, "Dropped nanoflow: %s.%s\n", s.Name.Module, s.Name.Name)
+			return nil
+		}
+	}
+
+	return mdlerrors.NewNotFound("nanoflow", s.Name.Module+"."+s.Name.Name)
+}

mdl/executor/exec_context.go

@@ -159,6 +159,22 @@ func (ctx *ExecContext) trackCreatedMicroflow(moduleName, mfName string, id, con
 	}
 }
 
+// trackCreatedNanoflow registers a nanoflow created during this session.
+func (ctx *ExecContext) trackCreatedNanoflow(moduleName, nfName string, id, containerID model.ID, returnEntityName string) {
+	ctx.ensureCache()
+	if ctx.Cache.createdNanoflows == nil {
+		ctx.Cache.createdNanoflows = make(map[string]*createdNanoflowInfo)
+	}
+	qualifiedName := moduleName + "." + nfName
+	ctx.Cache.createdNanoflows[qualifiedName] = &createdNanoflowInfo{
+		ID:               id,
+		Name:             nfName,
+		ModuleName:       moduleName,
+		ContainerID:      containerID,
+		ReturnEntityName: returnEntityName,
+	}
+}
+
 // trackCreatedPage registers a page created during this session.
 func (ctx *ExecContext) trackCreatedPage(moduleName, pageName string, id, containerID model.ID) {
 	ctx.ensureCache()

mdl/executor/executor.go

@@ -32,6 +32,7 @@ type executorCache struct {
 
 	// Track items created during this session (not yet visible via reader)
 	createdMicroflows map[string]*createdMicroflowInfo // qualifiedName -> info
+	createdNanoflows  map[string]*createdNanoflowInfo  // qualifiedName -> info
 	createdPages      map[string]*createdPageInfo      // qualifiedName -> info
 	createdSnippets   map[string]*createdSnippetInfo   // qualifiedName -> info
 
@@ -43,6 +44,7 @@ type executorCache struct {
 	// rewrites. Reusing both keeps the rewrite semantically equivalent to an
 	// in-place update.
 	droppedMicroflows map[string]*droppedUnitInfo // qualifiedName -> original IDs
+	droppedNanoflows  map[string]*droppedUnitInfo // qualifiedName -> original IDs
 
 	// Track domain models modified during this session for finalization
 	modifiedDomainModels map[model.ID]string // domain model unit ID -> module name
@@ -62,6 +64,15 @@ type createdMicroflowInfo struct {
 	ReturnEntityName string // Qualified entity name from return type (e.g., "Module.Entity")
 }
 
+// createdNanoflowInfo tracks a nanoflow created during this session.
+type createdNanoflowInfo struct {
+	ID               model.ID
+	Name             string
+	ModuleName       string
+	ContainerID      model.ID
+	ReturnEntityName string
+}
+
 // createdPageInfo tracks a page created during this session.
 type createdPageInfo struct {
 	ID          model.ID
@@ -373,3 +384,35 @@ func consumeDroppedMicroflow(ctx *ExecContext, qualifiedName string) *droppedUni
 	delete(ctx.Cache.droppedMicroflows, qualifiedName)
 	return info
 }
+
+// rememberDroppedNanoflow records the UnitID and ContainerID of a nanoflow
+// that was just deleted so a subsequent CREATE OR REPLACE/MODIFY can reuse them.
+func rememberDroppedNanoflow(ctx *ExecContext, qualifiedName string, id, containerID model.ID) {
+	if ctx == nil || qualifiedName == "" || id == "" {
+		return
+	}
+	if ctx.Cache == nil {
+		ctx.Cache = &executorCache{}
+	}
+	if ctx.Cache.droppedNanoflows == nil {
+		ctx.Cache.droppedNanoflows = make(map[string]*droppedUnitInfo)
+	}
+	ctx.Cache.droppedNanoflows[qualifiedName] = &droppedUnitInfo{
+		ID:          id,
+		ContainerID: containerID,
+	}
+}
+
+// consumeDroppedNanoflow returns the original IDs of a nanoflow dropped
+// earlier in this session (if any) and removes the entry.
+func consumeDroppedNanoflow(ctx *ExecContext, qualifiedName string) *droppedUnitInfo {
+	if ctx == nil || ctx.Cache == nil || ctx.Cache.droppedNanoflows == nil {
+		return nil
+	}
+	info, ok := ctx.Cache.droppedNanoflows[qualifiedName]
+	if !ok {
+		return nil
+	}
+	delete(ctx.Cache.droppedNanoflows, qualifiedName)
+	return info
+}