Translate syntax 3

pom.xml

@@ -87,7 +87,7 @@
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <java.enforced.version>[17,18)</java.enforced.version>
         <maven.compiler.release>8</maven.compiler.release>
-        <rosetta.dsl.version>9.15.1</rosetta.dsl.version>
+        <rosetta.dsl.version>0.0.0.translate-syntax-3-SNAPSHOT</rosetta.dsl.version>
 
         <!-- Release -->
         <gpg.keyname>configured-by-release-profile</gpg.keyname>
@@ -336,10 +336,10 @@
             <groupId>com.fasterxml.jackson.module</groupId>
             <artifactId>jackson-module-parameter-names</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.fasterxml.jackson.module</groupId>
-            <artifactId>jackson-module-blackbird</artifactId>
-        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>com.fasterxml.jackson.module</groupId>-->
+<!--            <artifactId>jackson-module-blackbird</artifactId>-->
+<!--        </dependency>-->
         <dependency>
             <groupId>com.fasterxml.jackson.datatype</groupId>
             <artifactId>jackson-datatype-jdk8</artifactId>

src/main/java/com/regnosys/rosetta/common/hashing/GlobalKeyProcessStep.java

@@ -65,7 +65,7 @@ public <T extends RosettaModelObject> KeyPostProcessReport runProcessStep(Class<
 		RosettaModelObjectBuilder builder = instance.toBuilder();
 		KeyPostProcessReport thisReport = new KeyPostProcessReport(builder, new HashMap<>());
 		ReKeyProcessor reKeyProcessor = new ReKeyProcessor(thisReport);
-		RosettaPath path = RosettaPath.valueOf(topClass.getSimpleName());
+		RosettaPath path = RosettaPath.valueOf(instance.getType().getSimpleName());
 		reKeyProcessor.processRosetta(path, topClass, builder, null);
 		builder.process(path, reKeyProcessor);
 		return thisReport;

src/main/java/com/regnosys/rosetta/common/hashing/ReKeyProcessStep.java

@@ -48,7 +48,7 @@ public ReKeyProcessStep(GlobalKeyProcessStep keyProcessor) {
 
 	@Override
 	public <T extends RosettaModelObject> PostProcessorReport runProcessStep(Class<? extends T> topClass, T instance) {
-		RosettaPath path = RosettaPath.valueOf(topClass.getSimpleName());
+		RosettaPath path = RosettaPath.valueOf(instance.getType().getSimpleName());
 		RosettaModelObjectBuilder builder = instance.toBuilder();
 		ReKeyPostProcessReport report = new ReKeyPostProcessReport(builder);
 		ReKeyProcessor processor = new ReKeyProcessor(report, keyProcessor.runProcessStep(topClass, instance));

src/main/java/com/regnosys/rosetta/common/hashing/ReferenceResolverProcessStep.java

@@ -70,7 +70,7 @@ public String getName() {
     public <T extends RosettaModelObject> ReferenceResolverPostProcessorReport runProcessStep(
             Class<? extends T> topClass,
             T instance) {
-        RosettaPath path = RosettaPath.valueOf(topClass.getSimpleName());
+        RosettaPath path = RosettaPath.valueOf(instance.getType().getSimpleName());
         ReferenceCollector collector = new ReferenceCollector(referenceConfig);
         instance.process(path, collector);
         ReferenceResolver resolver =

src/main/java/com/regnosys/rosetta/common/merging/MergeTemplateProcessStep.java

@@ -64,7 +64,7 @@ public String getName() {
 	@Override
 	public <T extends RosettaModelObject> PostProcessorReport runProcessStep(Class<? extends T> topClass, T instance) {
 		MergeTemplateBuilderProcessor process = new MergeTemplateBuilderProcessor();
-		RosettaPath path = RosettaPath.valueOf(topClass.getSimpleName());
+		RosettaPath path = RosettaPath.valueOf(instance.getType().getSimpleName());
 		RosettaModelObjectBuilder builder= instance.toBuilder();
 		process.processRosetta(path, topClass, builder, null);
 		builder.process(path, process);

src/main/java/com/regnosys/rosetta/common/postprocess/qualify/QualifyProcessorStep.java

@@ -54,7 +54,7 @@ public String getName() {
 
 	@Override
 	public <T extends RosettaModelObject> QualificationReport runProcessStep(Class<? extends T> topClass, T instance) {
-		RosettaPath path = RosettaPath.valueOf(topClass.getSimpleName());
+		RosettaPath path = RosettaPath.valueOf(instance.getType().getSimpleName());
 		RosettaModelObjectBuilder builder = (RosettaModelObjectBuilder) instance;
 
 		List<QualificationResult> collectedResults = new ArrayList<>();

src/main/java/com/regnosys/rosetta/common/serialisation/RosettaObjectMapper.java

@@ -21,7 +21,7 @@
  */
 
 import com.fasterxml.jackson.databind.*;
-import com.fasterxml.jackson.module.blackbird.BlackbirdModule;
+//import com.fasterxml.jackson.module.blackbird.BlackbirdModule;
 
 /**
  * Returns a pre-configured {@link ObjectMapper} that serves as the default when
@@ -42,7 +42,7 @@ public static ObjectMapper getNewMinimalRosettaObjectMapper() {
      * Creating new RosettaObjectMapper instances is expensive, use the singleton instance if possible.
      */
     public static ObjectMapper getNewRosettaObjectMapper() {
-        return getNewMinimalRosettaObjectMapper()
-                .registerModule(new BlackbirdModule());
+        return getNewMinimalRosettaObjectMapper();
+               // .registerModule(new BlackbirdModule());
     }
 }

src/main/java/com/regnosys/rosetta/common/serialisation/mixin/RosettaJSONAnnotationIntrospector.java

@@ -21,15 +21,19 @@
  */
 
 import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonUnwrapped;
 import com.fasterxml.jackson.core.Version;
 import com.fasterxml.jackson.databind.PropertyName;
 import com.fasterxml.jackson.databind.cfg.MapperConfig;
 import com.fasterxml.jackson.databind.introspect.*;
+import com.fasterxml.jackson.databind.util.NameTransformer;
 import com.regnosys.rosetta.common.serialisation.BackwardsCompatibleAnnotationIntrospector;
 import com.regnosys.rosetta.common.serialisation.BeanUtil;
 import com.regnosys.rosetta.common.serialisation.mixin.legacy.LegacyRosettaBuilderIntrospector;
 import com.rosetta.model.lib.annotations.RosettaAttribute;
 import com.rosetta.model.lib.annotations.RosettaDataType;
+import com.rosetta.model.lib.meta.RosettaOriginalProxy;
+import com.rosetta.model.lib.meta.RosettaProxy;
 
 import java.util.*;
 import java.util.function.Predicate;
@@ -68,6 +72,11 @@ public Class<?> findPOJOBuilder(AnnotatedClass ac) {
     public PropertyName findNameForSerialization(Annotated a) {
         if (a.hasAnnotation(RosettaAttribute.class)) {
             return new PropertyName(a.getAnnotation(RosettaAttribute.class).value());
+        } else if (a instanceof AnnotatedMethod) {
+            AnnotatedMethod m = (AnnotatedMethod) a;
+            if (RosettaProxy.class.isAssignableFrom(m.getDeclaringClass()) && m.getName().equals("getKey")) {
+                return new PropertyName("@referenceKey");
+            }
         }
         return super.findNameForSerialization(a);
     }
@@ -107,11 +116,30 @@ public JsonIgnoreProperties.Value findPropertyIgnoralByName(MapperConfig<?> conf
         return findPropertyIgnorals(ann);
     }
 
+    @Override
+    public NameTransformer findUnwrappingNameTransformer(AnnotatedMember member)
+    {
+        if (RosettaProxy.class.isAssignableFrom(member.getDeclaringClass()) && member.getName().equals("getInstance")) {
+            return NameTransformer.simpleTransformer("", "");
+        }
+        return super.findUnwrappingNameTransformer(member);
+    }
+
     @Deprecated
     @Override
     public JsonIgnoreProperties.Value findPropertyIgnorals(Annotated ac) {
         if (ac instanceof AnnotatedClass && ac.hasAnnotation(RosettaDataType.class)) {
             AnnotatedClass acc = (AnnotatedClass) ac;
+            if (RosettaProxy.class.isAssignableFrom(ac.getRawType())) {
+                Set<String> includedNames = new HashSet<>();
+                if (RosettaOriginalProxy.class.isAssignableFrom(ac.getRawType())) {
+                    includedNames.add("getInstance");
+                } else {
+                    includedNames.add("getKey");
+                }
+                Set<String> ignored = getPropertyNames(acc, x -> !includedNames.contains(x.getName()));
+                return JsonIgnoreProperties.Value.forIgnoredProperties(ignored).withAllowSetters();
+            }
             Set<String> includes = getPropertyNames(acc, x -> x.hasAnnotation(RosettaAttribute.class));
             Set<String> ignored = getPropertyNames(acc, x -> !x.hasAnnotation(RosettaAttribute.class));
             ignored.removeAll(includes);
@@ -125,7 +153,7 @@ public JsonIgnoreProperties.Value findPropertyIgnorals(Annotated ac) {
     private static Set<String> getPropertyNames(AnnotatedClass acc, Predicate<AnnotatedMethod> filter) {
         return StreamSupport.stream(acc.memberMethods().spliterator(), false)
                 .filter(filter)
-                .map(m -> BeanUtil.getPropertyName(m.getAnnotated()))
+                .map(m -> m.getName().equals("getKey") ? "@referenceKey" : BeanUtil.getPropertyName(m.getAnnotated()))
                 .filter(Objects::nonNull)
                 .collect(Collectors.toSet());
     }

src/main/java/com/regnosys/rosetta/common/translation/MappingProcessorStep.java

@@ -80,7 +80,7 @@ public <T extends RosettaModelObject> PostProcessorReport runProcessStep(Class<?
 		Stopwatch stopwatch = Stopwatch.createStarted();
 		RosettaModelObjectBuilder builder = instance.toBuilder();
 		Future<?> mappingsFuture = executor.submit(() -> {
-			RosettaPath path = RosettaPath.valueOf(topClass.getSimpleName());
+			RosettaPath path = RosettaPath.valueOf(instance.getType().getSimpleName());
 			for (MappingDelegate mapper : mappingDelegates) {
 				LOGGER.debug("Running mapper {} for model path {}", mapper.getClass().getSimpleName(), mapper.getModelPath());
 				MappingBuilderProcessor processor = new MappingBuilderProcessor(mapper);

src/main/java/com/regnosys/rosetta/common/util/RosettaObjectCollectorProcessStep.java

@@ -52,7 +52,7 @@ public String getName() {
 	public <T extends RosettaModelObject> RosettaObjectCollectorProcessReport<B> runProcessStep(Class<? extends T> topClass, T instance) {
 		List<B> collectedObjects = new ArrayList<>();
 		RosettaObjectCollectorProcess<B> process = new RosettaObjectCollectorProcess<>(collectRosettaType, collectedObjects);
-		RosettaPath path = RosettaPath.valueOf(topClass.getSimpleName());
+		RosettaPath path = RosettaPath.valueOf(instance.getType().getSimpleName());
 		process.processRosetta(path, topClass, instance, null);
 		instance.process(path, process);
 		return new RosettaObjectCollectorProcessReport<>(instance, collectedObjects);

src/main/java/com/regnosys/rosetta/common/validation/RosettaTypeValidator.java

@@ -49,10 +49,10 @@ public class RosettaTypeValidator implements PostProcessStep {
 
 	@Override
 	public <T extends RosettaModelObject> ValidationReport runProcessStep(Class<? extends T> topClass, T instance) {
-		LOGGER.debug("Running validation for " + topClass.getSimpleName());
+		LOGGER.debug("Running validation for " + instance.getType().getSimpleName());
 		ValidationReport report = new ValidationReport(instance, new ArrayList<>());
 		RosettaTypeProcessor processor = new RosettaTypeProcessor(report);
-		RosettaPath path = RosettaPath.valueOf(topClass.getSimpleName());
+		RosettaPath path = RosettaPath.valueOf(instance.getType().getSimpleName());
 		processor.processRosetta(path, topClass, instance, null);
 		instance.process(path, processor);
 		return report;

src/test/java/com/regnosys/rosetta/common/serialisation/json/ProxySerialisationTest.java

@@ -0,0 +1,86 @@
+package com.regnosys.rosetta.common.serialisation.json;
+
+/*-
+ * ==============
+ * Rune Common
+ * ==============
+ * Copyright (C) 2018 - 2024 REGnosys
+ * ==============
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ==============
+ */
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.regnosys.rosetta.common.serialisation.RosettaObjectMapper;
+import com.regnosys.rosetta.tests.RosettaInjectorProvider;
+import com.regnosys.rosetta.tests.util.CodeGeneratorTestHelper;
+import com.rosetta.model.lib.RosettaModelObject;
+import com.rosetta.model.lib.RosettaModelObjectBuilder;
+import com.rosetta.model.lib.annotations.RosettaDataType;
+import com.rosetta.model.lib.meta.ReferenceService;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import javax.inject.Inject;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@ExtendWith(InjectionExtension.class)
+@InjectWith(RosettaInjectorProvider.class)
+public class ProxySerialisationTest {
+
+    @Inject
+    CodeGeneratorTestHelper codeGeneratorTestHelper;
+    @Inject
+    ReferenceService referenceService;
+
+    @Test
+    void testProxySerialisation() throws JsonProcessingException {
+        ObjectMapper mapper = RosettaObjectMapper.getNewRosettaObjectMapper();
+
+        String rosetta = "type A:\n" +
+                "        attr1 string (0..1)\n" +
+                "        attr2 string (0..1)\n";
+
+        String expectedJson = "{\"@referenceKey\":\"key\"}";
+        String expectedOriginalJson = "{\"attr1\":\"foo\",\"attr2\":\"bar\"}";
+
+        HashMap<String, String> generatedCode = codeGeneratorTestHelper.generateCode(rosetta);
+        Map<String, Class<?>> compiledCode = codeGeneratorTestHelper.compileToClasses(generatedCode);
+
+        Class<RosettaModelObject> compiledClass = (Class<RosettaModelObject>)compiledCode.get("com.rosetta.test.model.A");
+
+        RosettaModelObject value = mapper.readValue(expectedOriginalJson, compiledClass);
+        RosettaModelObject originalInstance = referenceService.register(value, "key", compiledClass);
+        RosettaModelObject proxy = referenceService.getProxy("key", compiledClass);
+
+        String actualJson = mapper.writeValueAsString(proxy);
+        assertJsonEquals(expectedJson, actualJson);
+
+        String actualOriginalJson = mapper.writeValueAsString(originalInstance);
+        assertJsonEquals(expectedOriginalJson, actualOriginalJson);
+    }
+
+    private void assertJsonEquals(String expectedJson, String actualJson) throws JsonProcessingException {
+        ObjectMapper mapper = new ObjectMapper();
+        TreeMap<String, ?> expectedJsonMap = mapper.readValue(expectedJson, TreeMap.class);
+        TreeMap<String, ?> actualJsonMap = mapper.readValue(actualJson, TreeMap.class);
+        assertEquals(expectedJsonMap, actualJsonMap);
+    }
+}

src/test/java/com/regnosys/rosetta/common/translation/MappingProcessorStepTest.java

@@ -252,7 +252,7 @@ public RosettaModelObjectBuilder toBuilder() {
 
 		@Override
 		public Class<? extends RosettaModelObject> getType() {
-			throw new UnsupportedOperationException("method getType in RosettaModelObject has not been implemented");
+			return TestModel.class;
 		}
 
 		@Override