feat(map): Codegen for XMLSchema Target

lib/codegen/fromcto/typescript/typescriptvisitor.js

@@ -281,24 +281,33 @@ class TypescriptVisitor {
      * @private
      */
     visitMapDeclaration(mapDeclaration, parameters) {
-        // const keyType = mapDeclaration.getKey().getType(); // for now, key is always string.
-        let valueType = mapDeclaration.getValue().getType();
-
-        const isScalar = ModelUtil.isScalar(mapDeclaration.getValue());
-        const isPrimitive = ModelUtil.isPrimitiveType(mapDeclaration.getValue().getType());
+        const mapKeyType = mapDeclaration.getKey().getType();
+        const mapValueType = mapDeclaration.getValue().getType();
+
+        let keyType;
+        let valueType;
+
+        // Map Key Type
+        if (ModelUtil.isPrimitiveType(mapKeyType)) {
+            keyType = this.toTsType(mapDeclaration.getKey().getType(), false, false);
+        } else if (ModelUtil.isScalar(mapDeclaration.getKey())) {
+            const scalarDeclaration = mapDeclaration.getModelFile().getType(mapDeclaration.getKey().getType());
+            const scalarType = scalarDeclaration.getType();
+            keyType = this.toTsType(scalarType, false, false);
+        }
 
-        if (isScalar) {
-            const scalar = mapDeclaration.getModelFile(mapDeclaration.getValue().getType());
-            const scalarType = scalar.getType();
-            valueType = this.toTsType(scalarType, false, false);
-        } else if (isPrimitive) {
+        // Map Value Type
+        if (ModelUtil.isPrimitiveType(mapValueType)) {
             valueType = this.toTsType(mapDeclaration.getValue().getType(), false, false);
+        } else if (ModelUtil.isScalar(mapDeclaration.getValue())) {
+            const scalarDeclaration = mapDeclaration.getModelFile().getType(mapDeclaration.getValue().getType());
+            const scalarType = scalarDeclaration.getType();
+            valueType = this.toTsType(scalarType, false, false);
         } else {
-            valueType = this.toTsType(valueType, true, false);
-
+            valueType = this.toTsType(mapValueType, true, false);
         }
 
-        parameters.fileWriter.writeLine(0, 'export type ' + mapDeclaration.getName() + ` = Map<string, ${valueType}>;\n` );
+        parameters.fileWriter.writeLine(0, 'export type ' + mapDeclaration.getName() + ` = Map<${keyType}, ${valueType}>;\n` );
 
         return null;
     }

lib/codegen/fromcto/xmlschema/xmlschemavisitor.js

@@ -44,7 +44,7 @@ class XmlSchemaVisitor {
         } else if (thing.isClassDeclaration?.()) {
             return this.visitClassDeclaration(thing, parameters);
         } else if (thing.isMapDeclaration?.()) {
-            return;
+            return this.visitMapDeclaration(thing, parameters);
         } else if (thing.isTypeScalar?.()) {
             return this.visitField(thing.getScalarField(), parameters);
         } else if (thing.isField?.()) {
@@ -153,6 +153,39 @@ class XmlSchemaVisitor {
         return null;
     }
 
+    /**
+     * Visitor design pattern
+     * @param {MapDeclaration} mapDeclaration - the object being visited
+     * @param {Object} parameters  - the parameter
+     * @return {Object} the result of visiting or null
+     * @private
+     */
+    visitMapDeclaration(mapDeclaration, parameters) {
+
+        const key   = this.toXsType(mapDeclaration.getKey().getType(), mapDeclaration.getKey(), mapDeclaration);
+        const value = this.toXsType(mapDeclaration.getValue().getType(), mapDeclaration.getValue(), mapDeclaration);
+
+        // write the element representing the MapDeclaration
+        parameters.fileWriter.writeLine(0, `<xs:element name="${mapDeclaration.getName()}">` );
+        parameters.fileWriter.writeLine(0, '<xs:complexType>' );
+        parameters.fileWriter.writeLine(1, '<xs:sequence>');
+        parameters.fileWriter.writeLine(2, `<xs:element name="entry" type="${mapDeclaration.getName()}EntryType" minOccurs="0" maxOccurs="unbounded"/>`);
+        parameters.fileWriter.writeLine(1, '</xs:sequence>');
+        parameters.fileWriter.writeLine(0, '</xs:complexType>');
+        parameters.fileWriter.writeLine(0, '</xs:element>');
+
+        // write the Entry type reprenting the schema of the MapDeclaration
+        parameters.fileWriter.writeLine(0, `<xs:complexType name="${mapDeclaration.getName()}EntryType">` );
+        parameters.fileWriter.writeLine(1, '<xs:sequence>');
+        parameters.fileWriter.writeLine(2, `<xs:element name="key" type="${key}"/>`);
+        parameters.fileWriter.writeLine(2, `<xs:element name="value" type="${value}"/>`);
+        parameters.fileWriter.writeLine(1, '</xs:sequence>');
+        parameters.fileWriter.writeLine(0, '</xs:complexType>');
+
+        return null;
+    }
+
+
     /**
      * Visitor design pattern
      * @param {ClassDeclaration} classDeclaration - the object being visited
@@ -256,10 +289,12 @@ class XmlSchemaVisitor {
      * Converts a Concerto type to a XML Schema type. Primitive types are converted
      * everything else is passed through unchanged.
      * @param {string} type  - the fully qualified concerto type name
+     * @param {Object} mapElement  - the mapElement representing either the Key or Value of a MapDeclaration
+     * @param {MapDeclaration} mapDeclaration  - the object representing a MapDeclaration
      * @return {string} the corresponding type in XML Schema
      * @private
      */
-    toXsType(type) {
+    toXsType(type, mapElement, mapDeclaration) {
         switch(type) {
         case 'DateTime':
             return 'xs:dateTime';
@@ -274,6 +309,16 @@ class XmlSchemaVisitor {
         case 'Integer':
             return 'xs:integer';
         default:
+            if(!ModelUtil.getNamespace(type)) {
+                const typeDeclaration = mapDeclaration.getModelFile().getType(type);
+                if (typeDeclaration?.isClassDeclaration?.() && ['Concept', 'Asset', 'Transaction', 'Participant', 'Event'].includes(type)) {
+                    return  `concerto:${mapElement.getType()}`;
+                } else if (typeDeclaration?.isClassDeclaration?.() ) {
+                    return `${ModelUtil.parseNamespace(mapDeclaration.getModelFile().getNamespace()).name}:${mapElement.getType()}`;
+                } else if (typeDeclaration?.isScalarDeclaration?.()) {
+                    return this.toXsType(typeDeclaration.getType());
+                }
+            }
             return `${ModelUtil.parseNamespace(ModelUtil.getNamespace(type)).name}:${ModelUtil.getShortName(type)}`;
         }
     }