feat(concerto-core): implement YAML to JSON conversion for DCS (#1044)

* feat(dcsconverter): implement yaml to json conversion

- updated test files considering full coverage
- updated changelog and type files

Signed-off-by: fuyalasmit <[email protected]>

* update JSDoc and api changelog files

Signed-off-by: fuyalasmit <[email protected]>

---------

Signed-off-by: fuyalasmit <[email protected]>

Author: fuyalasmit

packages/concerto-core/api.txt

@@ -56,11 +56,8 @@ class Concerto {
    + string getNamespace(obj) 
 }
    + object setCurrentTime() 
-   + object handleTarget() 
-   + object handleArguments() 
-   + object handleDecorator() 
-   + object handleCommands() 
-   + string jsonToYaml() throws Error
+   + string jsonToYaml() 
+   + object yamlToJson() 
 class DecoratorManager {
    + ModelManager validate(decoratorCommandSet,ModelFile[]) throws Error
    + object migrateTo(decoratorCommandSet,string) 
@@ -76,6 +73,7 @@ class DecoratorManager {
    + void executePropertyCommand(property,command) 
    + Boolean isNamespaceTargetEnabled(boolean?) 
    + string jsonToYaml(object) 
+   + object yamlToJson(string) 
 }
    + string[] intersect() 
    + boolean isUnversionedNamespaceEqual() 

packages/concerto-core/changelog.txt

@@ -24,8 +24,9 @@
 # Note that the latest public API is documented using JSDocs and is available in api.txt.
 #
 
-Version 3.22.0 {59de1f67703a76ab4a0f0c986775e889} 2025-07-12
+Version 3.22.0 {677eac41f1ef471977d3e301e46ef480} 2025-07-26
 - added jsonToYaml method in DecoratorManager
+- added yamlToJson method in DecoratorManager
 
 Version 3.20.5 {a18e77c836e19a4badcbe83d6c7e7c1e} 2025-02-03
 - vocabulary support for namespace scoped decorators

packages/concerto-core/lib/dcsconverter.js

@@ -16,11 +16,13 @@
 
 const yaml = require('yaml');
 const ModelUtil  = require('./modelutil');
+const { MetaModelNamespace } = require('@accordproject/concerto-metamodel');
 
 /**
  * handles the target field of a command
  * @param {object} target the value of target
  * @returns {object} the simplified target object
+ * @private
  */
 function handleTarget(target){
     const targetKeys = Object.keys(target);
@@ -42,12 +44,13 @@ function handleTarget(target){
  * @param {object} [argument.type] the type identifier for type reference arguments
  * @param {boolean} [argument.isArray] whether the type reference is an array
  * @returns {object} simplified argument object
+ * @private
  */
 function handleArguments(argument){
     const mapClassToType = {
-        '[email protected].DecoratorString': 'String',
-        '[email protected].DecoratorNumber': 'Number',
-        '[email protected].DecoratorBoolean': 'Boolean',
+        [`${MetaModelNamespace}.DecoratorString`]: 'String',
+        [`${MetaModelNamespace}.DecoratorNumber`]: 'Number',
+        [`${MetaModelNamespace}.DecoratorBoolean`]: 'Boolean',
     };
     if (argument.$class.endsWith('TypeReference')) {
         return {
@@ -71,6 +74,7 @@ function handleArguments(argument){
  * @param {string} decorator.name the name of the decorator
  * @param {object[]} [decorator.arguments] the list of arguments
  * @returns {object} simplified decorator object with name and arguments
+ * @private
  */
 function handleDecorator(decorator){
     return {
@@ -88,6 +92,7 @@ function handleDecorator(decorator){
  * @param {object} command.target the target to apply decorator to
  * @param {object} command.decorator the decorator to apply
  * @returns {object} simplified commands object
+ * @private
  */
 function handleCommands(command){
     return {
@@ -101,7 +106,6 @@ function handleCommands(command){
  * converts DCS JSON to YAML string
  * @param {object} dcsJson the DCS JSON as parsed object
  * @returns {string} the DCS YAML string
- * @throws {Error} if the input is not a valid DCS JSON
  */
 function jsonToYaml(dcsJson){
     const dcsNamespace = ModelUtil.getNamespace(dcsJson.$class);
@@ -121,4 +125,95 @@ function jsonToYaml(dcsJson){
     return yamlString;
 }
 
-module.exports = { jsonToYaml };
+
+/**
+ * handles each argument of the decorator
+ * converts simplified argument objects back to full JSON representation
+ * @param {string} MetaModelNamespace - the metamodel namespace
+ * @param {object} argument - the simplified argument object
+ * @param {string} [argument.type] - the argument type for primitive values
+ * @param {*} [argument.value] - the argument value
+ * @param {object} [argument.typeReference] - the type reference object for complex types
+ * @returns {object} - the fully qualified argument object after restoring required fields
+ * @private
+ */
+function restoreArguments(MetaModelNamespace, argument){
+    const mapTypeToClass = {
+        'String': `${MetaModelNamespace}.DecoratorString`,
+        'Number': `${MetaModelNamespace}.DecoratorNumber`,
+        'Boolean': `${MetaModelNamespace}.DecoratorBoolean`,
+    };
+    if ( Object.keys(argument)[0] === 'typeReference' ) {
+        return {
+            $class: ModelUtil.getFullyQualifiedName(MetaModelNamespace, 'DecoratorTypeReference'),
+            type: {
+                $class: ModelUtil.getFullyQualifiedName(MetaModelNamespace, 'TypeIdentifier'),
+                name: argument.typeReference.name,
+                ... ( argument.typeReference.namespace !== undefined ? { namespace: argument.typeReference.namespace } : {} ),
+                ... ( argument.typeReference.resolvedName !== undefined ? { resolvedName: argument.typeReference.resolvedName } : {} ),
+            },
+            isArray: argument.typeReference.isArray
+        };
+    }
+    return {
+        $class: mapTypeToClass[argument.type],
+        value: argument.type === 'String' ? String(argument.value) : argument.value  ,
+    };
+}
+
+
+/**
+ * handles the decorator of each command for yaml to json
+ * @param {object} decorator - the decorator to convert
+ * @returns {object} - the decorator object after restoring required fields
+ * @private
+ */
+function restoreDecorator(decorator){
+    return {
+        $class: ModelUtil.getFullyQualifiedName(MetaModelNamespace, 'Decorator'),
+        name: decorator.name,
+        arguments: decorator.arguments ? decorator.arguments.map((argument) => restoreArguments(MetaModelNamespace, argument)) : [],
+    };
+}
+
+
+/**
+ * handles the command for yaml to json method
+ * @param {string} dcsNamespace - the namespace of the DCS
+ * @param {object} command - the command to convert
+ * @returns {object} - the command object after restoring required fields
+ * @private
+ */
+function restoreCommands(dcsNamespace, command){
+    return {
+        $class: ModelUtil.getFullyQualifiedName(dcsNamespace, 'Command'),
+        type: command.action,
+        target: {
+            $class: ModelUtil.getFullyQualifiedName(dcsNamespace, 'CommandTarget'),
+            ... command.target
+        },
+        decorator: restoreDecorator(command.decorator)
+    };
+}
+
+
+/**
+ * converts DCS YAML string to JSON format
+ * @param {string} yamlString the YAML string to convert
+ * @returns {object} the DCS JSON
+ */
+function yamlToJson(yamlString){
+    const parsedJson = yaml.parse(yamlString);
+    const dcsNamespace = 'org.accordproject.decoratorcommands@' + parsedJson.decoratorCommandsVersion;
+    const dcsJson = {
+        $class: ModelUtil.getFullyQualifiedName(dcsNamespace, 'DecoratorCommandSet'),
+        name: parsedJson.name,
+        version: parsedJson.version,
+        commands: parsedJson.commands.map((command) => restoreCommands(dcsNamespace, command)),
+    };
+
+    return dcsJson;
+}
+
+
+module.exports = { jsonToYaml, yamlToJson };

packages/concerto-core/lib/decoratormanager.js

@@ -28,7 +28,7 @@ const rfdc = require('rfdc')({
     proto: false,
 });
 
-const { jsonToYaml } = require('./dcsconverter');
+const { jsonToYaml, yamlToJson } = require('./dcsconverter');
 
 // Types needed for TypeScript generation.
 /* eslint-disable no-unused-vars */
@@ -864,6 +864,19 @@ class DecoratorManager {
         this.validate(jsonInput);
         return jsonToYaml(jsonInput);
     }
+
+    /**
+     * converts DCS YAML string into JSON object
+     * validates the output DCS JSON against the DCS model
+     * @param {string} yamlInput the DCS JSON as parsed object
+     * @return {object} the corresponding JSON object
+     */
+    static yamlToJson(yamlInput){
+        const jsonOutput = yamlToJson(yamlInput);
+        this.validate(jsonOutput);
+        return jsonOutput;
+    }
+
 }
 
 module.exports = DecoratorManager;