feat: redesign import/export mapping syntax v2

Assignment-style syntax that reads naturally and removes redundancy:

Import:  CREATE Module.Entity { Attr = jsonField KEY }
Export:  Module.Entity { jsonField = Attr }
Nested:  CREATE Assoc/Entity = jsonKey { ... }
Schema:  WITH JSON STRUCTURE (replaces FROM/TO)

Key changes:
- Entity-first: what you're building is prominent, not the JSON field
- No type annotations: entity already defines attribute types
- Association paths: Assoc/Entity instead of VIA keyword
- Handling keywords: CREATE, FIND, FIND OR CREATE before entity
- Value transforms: Attr = Module.Microflow(jsonField) (grammar ready)
- Commas between elements, consistent with database client mappings

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

Author: ako

.claude/skills/mendix/rest-call-from-json.md

@@ -65,25 +65,26 @@ CREATE ASSOCIATION Module.MyRootObject_MyNestedObject
 
 ```sql
 CREATE IMPORT MAPPING Module.IMM_MyMapping
-  FROM JSON STRUCTURE Module.JSON_MyStructure
+  WITH JSON STRUCTURE Module.JSON_MyStructure
 {
-  "" AS Module.MyRootObject (Create) {
-    nestedKey AS Module.MyNestedObject (Create) VIA Module.MyRootObject_MyNestedObject {
-      name AS name (String),
-      code AS code (String)
-    },
-    stringField AS stringField (String),
-    intField    AS intField    (Integer)
+  CREATE Module.MyRootObject {
+    stringField = stringField,
+    intField    = intField,
+    CREATE Module.MyRootObject_MyNestedObject/Module.MyNestedObject = nestedKey {
+      name = name,
+      code = code
+    }
   }
 };
 ```
 
 **Syntax rules:**
-- Root element uses `""` (empty string) as the JSON key — it maps the top-level object
-- Object mappings: `jsonKey AS Module.Entity (Create|Find|FindOrCreate)`
-- Value mappings: `jsonKey AS attributeName (String|Integer|Long|Decimal|Boolean|DateTime)`
-- `VIA Module.Association` — required when mapping a nested object reachable via an association
-- No semicolons between child elements inside `{}`
+- Root object: `CREATE Module.Entity { ... }` — always starts with handling keyword
+- Value mappings: `AttributeName = jsonFieldName` — entity attribute on the left, JSON field on the right
+- Nested objects: `CREATE Association/Entity = jsonKey { ... }` — association path + JSON key
+- Object handling: `CREATE` (default), `FIND` (requires KEY), `FIND OR CREATE`
+- KEY marker: `Attr = jsonField KEY` — marks the attribute as a matching key
+- Value transforms: `Attr = Module.Microflow(jsonField)` — call a microflow to transform the value
 
 **Verify** after creation — check Schema elements are ticked in Studio Pro:
 - Open the import mapping in Studio Pro
@@ -166,22 +167,22 @@ CREATE ASSOCIATION Integrations.BibleApiResponse_BibleVerse
 
 -- Step 3: Import Mapping
 CREATE IMPORT MAPPING Integrations.IMM_BibleVerse
-  FROM JSON STRUCTURE Integrations.JSON_BibleVerse
+  WITH JSON STRUCTURE Integrations.JSON_BibleVerse
 {
-  "" AS Integrations.BibleApiResponse (Create) {
-    translation AS Integrations.BibleTranslation (Create) VIA Integrations.BibleApiResponse_BibleTranslation {
-      identifier    AS identifier    (String),
-      language      AS language      (String),
-      language_code AS language_code (String),
-      license       AS license       (String),
-      name          AS name          (String)
+  CREATE Integrations.BibleApiResponse {
+    CREATE Integrations.BibleApiResponse_BibleTranslation/Integrations.BibleTranslation = translation {
+      identifier    = identifier,
+      language      = language,
+      language_code = language_code,
+      license       = license,
+      name          = name
     },
-    random_verse AS Integrations.BibleVerse (Create) VIA Integrations.BibleApiResponse_BibleVerse {
-      book    AS book    (String),
-      book_id AS book_id (String),
-      chapter AS chapter (Integer),
-      text    AS text    (String),
-      verse   AS verse   (Integer)
+    CREATE Integrations.BibleApiResponse_BibleVerse/Integrations.BibleVerse = random_verse {
+      book    = book,
+      book_id = book_id,
+      chapter = chapter,
+      text    = text,
+      verse   = verse
     }
   }
 };

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

@@ -1207,12 +1207,12 @@ CREATE NON-PERSISTENT ENTITY RestTest.PetResponse (
 /
 
 CREATE IMPORT MAPPING RestTest.IMM_Pet
-  FROM JSON STRUCTURE RestTest.JSON_Pet
+  WITH JSON STRUCTURE RestTest.JSON_Pet
 {
-  "" AS RestTest.PetResponse (Create) {
-    id AS PetId (Integer, KEY),
-    name AS Name (String),
-    status AS Status (String)
+  CREATE RestTest.PetResponse {
+    PetId = id,
+    Name = name,
+    Status = status
   }
 };
 
@@ -1251,22 +1251,55 @@ CREATE ASSOCIATION RestTest.OrderResponse_OrderItem
 /
 
 CREATE IMPORT MAPPING RestTest.IMM_Order
-  FROM JSON STRUCTURE RestTest.JSON_Order
+  WITH JSON STRUCTURE RestTest.JSON_Order
 {
-  "" AS RestTest.OrderResponse (Create) {
-    orderId AS OrderId (Integer, KEY),
-    customer AS RestTest.CustomerInfo (Create) VIA RestTest.OrderResponse_CustomerInfo {
-      email AS Email (String),
-      name AS Name (String)
+  CREATE RestTest.OrderResponse {
+    OrderId = orderId KEY,
+    CREATE RestTest.OrderResponse_CustomerInfo/RestTest.CustomerInfo = customer {
+      Email = email,
+      Name = name
     },
-    items AS RestTest.OrderItem (Create) VIA RestTest.OrderResponse_OrderItem {
-      price AS Price (Decimal),
-      quantity AS Quantity (Integer),
-      sku AS Sku (String)
+    CREATE RestTest.OrderResponse_OrderItem/RestTest.OrderItem = items {
+      Sku = sku,
+      Quantity = quantity,
+      Price = price
     }
   }
 };
 
+-- ============================================================================
+-- Level 13.3: Find Or Create Import Mapping
+-- ============================================================================
+--
+-- Uses FIND OR CREATE to upsert: find existing by KEY, create if not found.
+
+CREATE IMPORT MAPPING RestTest.IMM_UpsertPet
+  WITH JSON STRUCTURE RestTest.JSON_Pet
+{
+  FIND OR CREATE RestTest.PetResponse {
+    PetId = id KEY,
+    Name = name,
+    Status = status
+  }
+};
+
+-- ============================================================================
+-- Level 13.4: Import Mapping with Value Transform
+-- ============================================================================
+--
+-- Demonstrates calling a microflow to transform a JSON value during import.
+-- The microflow receives the raw JSON field value and returns the converted type.
+
+-- CREATE IMPORT MAPPING RestTest.IMM_TransformPet
+--   WITH JSON STRUCTURE RestTest.JSON_Pet
+-- {
+--   CREATE RestTest.PetResponse {
+--     PetId = id,
+--     Name = RestTest.TrimAndUpperCase(name),
+--     Status = status
+--   }
+-- };
+
 -- ############################################################################
 -- PART 14: EXPORT MAPPINGS
 -- ############################################################################
@@ -1280,12 +1313,12 @@ CREATE IMPORT MAPPING RestTest.IMM_Order
 -- Maps an entity back to JSON for outgoing REST calls.
 
 CREATE EXPORT MAPPING RestTest.EMM_Pet
-  TO JSON STRUCTURE RestTest.JSON_Pet
+  WITH JSON STRUCTURE RestTest.JSON_Pet
 {
-  RestTest.PetResponse AS root {
-    PetId AS id (Integer),
-    Name AS name (String),
-    Status AS status (String)
+  RestTest.PetResponse {
+    id = PetId,
+    name = Name,
+    status = Status
   }
 };
 
@@ -1296,19 +1329,19 @@ CREATE EXPORT MAPPING RestTest.EMM_Pet
 -- Demonstrates configurable null value handling (LeaveOutElement vs SendAsNil).
 
 CREATE EXPORT MAPPING RestTest.EMM_Order
-  TO JSON STRUCTURE RestTest.JSON_Order
+  WITH JSON STRUCTURE RestTest.JSON_Order
   NULL VALUES LeaveOutElement
 {
-  RestTest.OrderResponse AS root {
-    OrderId AS orderId (Integer),
-    RestTest.CustomerInfo VIA RestTest.OrderResponse_CustomerInfo AS customer {
-      Email AS email (String),
-      Name AS name (String)
+  RestTest.OrderResponse {
+    orderId = OrderId,
+    RestTest.OrderResponse_CustomerInfo/RestTest.CustomerInfo AS customer {
+      email = Email,
+      name = Name
     },
-    RestTest.OrderItem VIA RestTest.OrderResponse_OrderItem AS items {
-      Price AS price (Decimal),
-      Quantity AS quantity (Integer),
-      Sku AS sku (String)
+    RestTest.OrderResponse_OrderItem/RestTest.OrderItem AS items {
+      price = Price,
+      quantity = Quantity,
+      sku = Sku
     }
   }
 };

mdl/ast/ast_import_export_mapping.go

@@ -9,8 +9,13 @@ package ast
 // CreateImportMappingStmt represents:
 //
 //	CREATE IMPORT MAPPING Module.Name
-//	  [FROM JSON STRUCTURE Module.JsonStructure | FROM XML SCHEMA Module.Schema]
-//	{ root AS Module.Entity (Create) { ... } }
+//	  WITH JSON STRUCTURE Module.JsonStructure
+//	{
+//	  CREATE Module.Entity {
+//	    PetId = id KEY,
+//	    Name = name
+//	  }
+//	};
 type CreateImportMappingStmt struct {
 	Name        QualifiedName
 	SchemaKind  string        // "JSON_STRUCTURE" or "XML_SCHEMA" or ""
@@ -28,19 +33,23 @@ type DropImportMappingStmt struct {
 func (s *DropImportMappingStmt) isStatement() {}
 
 // ImportMappingElementDef represents one element in the mapping tree.
-// It may be an object mapping (AS entity) or a value mapping (AS attribute).
 type ImportMappingElementDef struct {
-	// JSON field name (or "root" for the root element)
-	JsonName string
-	// Object mapping fields (set when mapping to an entity)
+	// Object mapping fields
 	Entity         string // qualified entity name (e.g. "Module.Customer")
-	ObjectHandling string // "Create", "Find", "FindOrCreate", "Custom"
-	Association    string // qualified association name for via clause
+	ObjectHandling string // "Create", "Find", "FindOrCreate"
+	Association    string // qualified association name (from Assoc/Entity path)
 	Children       []*ImportMappingElementDef
-	// Value mapping fields (set when mapping to an attribute)
-	Attribute string // attribute name (unqualified, e.g. "Name")
-	DataType  string // "String", "Integer", "Boolean", "Decimal", "DateTime"
+
+	// Value mapping fields
+	Attribute string // entity attribute name (LHS of =)
 	IsKey     bool
+
+	// Shared
+	JsonName string // JSON field name (RHS of = for both values and objects)
+
+	// Value transform via microflow
+	Converter      string // microflow qualified name (e.g. "Module.ConvertStringToDate")
+	ConverterParam string // json field passed to converter
 }
 
 // ============================================================================
@@ -50,9 +59,13 @@ type ImportMappingElementDef struct {
 // CreateExportMappingStmt represents:
 //
 //	CREATE EXPORT MAPPING Module.Name
-//	  [TO JSON STRUCTURE Module.JsonStructure | TO XML SCHEMA Module.Schema]
-//	  [NULL VALUES LeaveOutElement | SendAsNil]
-//	{ Module.Entity AS root { ... } }
+//	  WITH JSON STRUCTURE Module.JsonStructure
+//	{
+//	  Module.Entity {
+//	    jsonField = Attr,
+//	    Module.Assoc/Module.Child AS jsonKey { ... }
+//	  }
+//	};
 type CreateExportMappingStmt struct {
 	Name            QualifiedName
 	SchemaKind      string        // "JSON_STRUCTURE" or "XML_SCHEMA" or ""
@@ -71,15 +84,15 @@ type DropExportMappingStmt struct {
 func (s *DropExportMappingStmt) isStatement() {}
 
 // ExportMappingElementDef represents one element in an export mapping tree.
-// It may be an object mapping (entity AS JSON key) or a value mapping (attribute AS JSON key).
 type ExportMappingElementDef struct {
-	// JSON field name (the RHS of AS)
-	JsonName string
-	// Object mapping fields (set when mapping from an entity)
+	// Object mapping fields
 	Entity      string // qualified entity name (e.g. "Module.Customer")
-	Association string // qualified association name for VIA clause
+	Association string // qualified association name (from Assoc/Entity path)
 	Children    []*ExportMappingElementDef
-	// Value mapping fields (set when mapping from an attribute)
-	Attribute string // attribute name (unqualified, e.g. "Name")
-	DataType  string // "String", "Integer", "Boolean", "Decimal", "DateTime"
+
+	// Value mapping fields
+	Attribute string // entity attribute name (RHS of =)
+
+	// Shared
+	JsonName string // JSON field name (LHS of = for values, RHS of AS for objects)
 }

mdl/executor/cmd_export_mappings.go

@@ -119,9 +119,9 @@ func (e *Executor) describeExportMapping(name ast.QualifiedName) error {
 	fmt.Fprintf(e.output, "CREATE EXPORT MAPPING %s.%s\n", moduleName, em.Name)
 
 	if em.JsonStructure != "" {
-		fmt.Fprintf(e.output, "  TO JSON STRUCTURE %s\n", em.JsonStructure)
+		fmt.Fprintf(e.output, "  WITH JSON STRUCTURE %s\n", em.JsonStructure)
 	} else if em.XmlSchema != "" {
-		fmt.Fprintf(e.output, "  TO XML SCHEMA %s\n", em.XmlSchema)
+		fmt.Fprintf(e.output, "  WITH XML SCHEMA %s\n", em.XmlSchema)
 	}
 
 	if em.NullValueOption != "" && em.NullValueOption != "LeaveOutElement" {
@@ -131,47 +131,46 @@ func (e *Executor) describeExportMapping(name ast.QualifiedName) error {
 	if len(em.Elements) > 0 {
 		fmt.Fprintln(e.output, "{")
 		for _, elem := range em.Elements {
-			printExportMappingElement(e, elem, 1)
+			printExportMappingElement(e, elem, 1, true)
 			fmt.Fprintln(e.output)
 		}
 		fmt.Fprintln(e.output, "};")
 	}
 	return nil
 }
 
-func printExportMappingElement(e *Executor, elem *model.ExportMappingElement, depth int) {
+func printExportMappingElement(e *Executor, elem *model.ExportMappingElement, depth int, isRoot bool) {
 	indent := strings.Repeat("  ", depth)
 	if elem.Kind == "Object" {
-		via := ""
-		if elem.Association != "" {
-			via = " VIA " + elem.Association
+		if isRoot {
+			// Root: Module.Entity {
+			fmt.Fprintf(e.output, "%s%s {\n", indent, elem.Entity)
+		} else {
+			// Nested: Assoc/Entity AS jsonKey {
+			fmt.Fprintf(e.output, "%s%s/%s AS %s", indent, elem.Association, elem.Entity, elem.ExposedName)
+			if len(elem.Children) > 0 {
+				fmt.Fprintln(e.output, " {")
+			}
 		}
 		if len(elem.Children) > 0 {
-			fmt.Fprintf(e.output, "%s%s%s AS %s {\n", indent, elem.Entity, via, elem.ExposedName)
 			for i, child := range elem.Children {
-				printExportMappingElement(e, child, depth+1)
+				printExportMappingElement(e, child, depth+1, false)
 				if i < len(elem.Children)-1 {
 					fmt.Fprintln(e.output, ",")
 				} else {
 					fmt.Fprintln(e.output)
 				}
 			}
 			fmt.Fprintf(e.output, "%s}", indent)
-		} else {
-			fmt.Fprintf(e.output, "%s%s%s AS %s", indent, elem.Entity, via, elem.ExposedName)
 		}
 	} else {
-		// Value mapping
+		// Value mapping: jsonField = Attr
 		attrName := elem.Attribute
 		// Strip module prefix if present (Module.Entity.Attr → Attr)
 		if parts := strings.Split(attrName, "."); len(parts) == 3 {
 			attrName = parts[2]
 		}
-		dt := elem.DataType
-		if dt == "" {
-			dt = "String"
-		}
-		fmt.Fprintf(e.output, "%s%s AS %s (%s)", indent, attrName, elem.ExposedName, dt)
+		fmt.Fprintf(e.output, "%s%s = %s", indent, elem.ExposedName, attrName)
 	}
 }
 
@@ -295,10 +294,7 @@ func buildExportMappingElementModel(moduleName string, def *ast.ExportMappingEle
 		// Value mapping — qualify attribute name as Module.Entity.Attribute
 		elem.Kind = "Value"
 		elem.TypeName = "ExportMappings$ValueMappingElement"
-		elem.DataType = def.DataType
-		if elem.DataType == "" {
-			elem.DataType = "String"
-		}
+		elem.DataType = "String" // default; entity already defines the real type
 		attr := def.Attribute
 		if parentEntity != "" && !strings.Contains(attr, ".") {
 			attr = parentEntity + "." + attr