@accordproject/concerto-core 1.2.2-20211124164813 → 1.2.2-20211124205408

package/README.md

@@ -1,6 +1,6 @@
 # Concerto Core
 
-Main library for Concerto model parsing, model manager, JSON instance validation and serialization.
+Main library for Concerto models, model manager, JSON instance validation and serialization.
 
 # Installation
 

package/changelog.txt

@@ -24,7 +24,7 @@
 # Note that the latest public API is documented using JSDocs and is available in api.txt.
 #
 
-Version 1.2.2 {82c68f1a011449a7783092b0aff0b928} 2021-11-24
+Version 1.2.2 {5b6204cb85376284c240cd69ffb06734} 2021-11-22
 - Remove custom instanceof and add methods to check runtime type
 - Remove support for Node 12
 - Generate Typescript definitions from JSDoc

package/lib/introspect/metamodel.js

@@ -14,15 +14,20 @@
 
 'use strict';
 
-const parser = require('./parser');
+const { Printer } = require('@accordproject/concerto-cto');
 const ModelManager = require('../modelmanager');
 const Factory = require('../factory');
 const Serializer = require('../serializer');
 
 /**
- * The metamodel itself, as a CTO string
+ * Class to work with the Concerto metamodel
  */
-const metaModelCto = `namespace concerto.metamodel
+class MetaModel {
+
+    /**
+     * The metamodel itself, as a CTO string
+     */
+    static metaModelCto = `namespace concerto.metamodel
 
 concept Position {
   o Integer line
@@ -188,6 +193,7 @@ concept ImportType extends Import {
 
 concept Model {
   o String namespace
+  o String sourceUri optional
   o String concertoVersion optional
   o Import[] imports optional
   o Declaration[] declarations optional
@@ -198,26 +204,13 @@ concept Models {
 }
 `;
 
-/**
- * Class to work with the Concerto metamodel
- */
-class MetaModel {
-
-    /**
-     * Returns the metamodel CTO
-     * @returns {string} the metamodel as a CTO string
-     */
-    static getMetaModelCto() {
-        return metaModelCto;
-    }
-
     /**
      * Create a metamodel manager (for validation against the metamodel)
      * @return {*} the metamodel manager
      */
     static createMetaModelManager() {
         const metaModelManager = new ModelManager();
-        metaModelManager.addModelFile(metaModelCto, 'concerto.metamodel');
+        metaModelManager.addModelFile(MetaModel.metaModelCto, 'concerto.metamodel');
         return metaModelManager;
     }
 
@@ -367,11 +360,15 @@ class MetaModel {
      * Resolve the namespace for names in the metamodel
      * @param {object} modelManager - the ModelManager
      * @param {object} metaModel - the MetaModel
+     * @param {boolean} [validate] - whether to perform validation
      * @return {object} the resolved metamodel
      */
-    static resolveMetaModel(modelManager, metaModel) {
-        const result = JSON.parse(JSON.stringify(metaModel));
-        const nameTable = MetaModel.createNameTable(modelManager, metaModel);
+    static resolveMetaModel(modelManager, metaModel, validate = true) {
+        // First, validate the JSON metaModel
+        const mm = validate ? MetaModel.validateMetaModel(metaModel) : metaModel;
+
+        const result = JSON.parse(JSON.stringify(mm));
+        const nameTable = MetaModel.createNameTable(modelManager, mm);
         // This adds the fully qualified names to the same object
         MetaModel.resolveTypeNames(result, nameTable);
         return result;
@@ -383,7 +380,7 @@ class MetaModel {
      * @param {boolean} [validate] - whether to perform validation
      * @return {object} the metamodel for this model
      */
-    static modelFileToMetaModel(modelFile, validate) {
+    static modelFileToMetaModel(modelFile, validate = true) {
         // Last, validate the JSON metaModel
         return validate ? MetaModel.validateMetaModel(modelFile.ast) : modelFile.ast;
     }
@@ -395,7 +392,7 @@ class MetaModel {
      * @param {boolean} [validate] - whether to perform validation
      * @return {object} the metamodel for this model manager
      */
-    static modelManagerToMetaModel(modelManager, resolve, validate) {
+    static modelManagerToMetaModel(modelManager, resolve, validate = true) {
         const result = {
             $class: 'concerto.metamodel.Models',
             models: [],
@@ -403,293 +400,34 @@ class MetaModel {
         modelManager.getModelFiles().forEach((modelFile) => {
             let metaModel = modelFile.ast;
             if (resolve) {
-                metaModel = MetaModel.resolveMetaModel(modelManager, metaModel);
+                // No need to re-validate when models are obtained from model manager
+                metaModel = MetaModel.resolveMetaModel(modelManager, metaModel, false);
             }
             result.models.push(metaModel);
         });
         return result;
     }
 
-    /**
-     * Create decorator argument string from a metamodel
-     * @param {object} mm - the metamodel
-     * @return {string} the string for the decorator argument
-     */
-    static decoratorArgFromMetaModel(mm) {
-        let result = '';
-        switch (mm.$class) {
-        case 'concerto.metamodel.DecoratorTypeReference':
-            result += `${mm.type.name}${mm.isArray ? '[]' : ''}`;
-            break;
-        case 'concerto.metamodel.DecoratorString':
-            result += `"${mm.value}"`;
-            break;
-        default:
-            result += `${mm.value}`;
-            break;
-        }
-        return result;
-    }
-
-    /**
-     * Create decorator string from a metamodel
-     * @param {object} mm - the metamodel
-     * @return {string} the string for the decorator
-     */
-    static decoratorFromMetaModel(mm) {
-        let result = '';
-        result += `@${mm.name}`;
-        if (mm.arguments) {
-            result += '(';
-            result += mm.arguments.map(MetaModel.decoratorArgFromMetaModel).join(',');
-            result += ')';
-        }
-        return result;
-    }
-
-    /**
-     * Create decorators string from a metamodel
-     * @param {object} mm - the metamodel
-     * @param {string} prefix - indentation
-     * @return {string} the string for the decorators
-     */
-    static decoratorsFromMetaModel(mm, prefix) {
-        let result = '';
-        result += mm.map(MetaModel.decoratorFromMetaModel).join(`\n${prefix}`);
-        result += `\n${prefix}`;
-        return result;
-    }
-
-    /**
-     * Create a property string from a metamodel
-     * @param {object} mm - the metamodel
-     * @return {string} the string for that property
-     */
-    static propertyFromMetaModel(mm) {
-        let result = '';
-        let defaultString = '';
-        let validatorString = '';
-
-        if (mm.decorators) {
-            result += MetaModel.decoratorsFromMetaModel(mm.decorators, '  ');
-        }
-        if (mm.$class === 'concerto.metamodel.RelationshipProperty') {
-            result += '-->';
-        } else {
-            result += 'o';
-        }
-
-        switch (mm.$class) {
-        case 'concerto.metamodel.EnumProperty':
-            break;
-        case 'concerto.metamodel.BooleanProperty':
-            result += ' Boolean';
-            if (mm.defaultValue === true || mm.defaultValue === false) {
-                if (mm.defaultValue) {
-                    defaultString += ' default=true';
-                } else {
-                    defaultString += ' default=false';
-                }
-            }
-            break;
-        case 'concerto.metamodel.DateTimeProperty':
-            result += ' DateTime';
-            break;
-        case 'concerto.metamodel.DoubleProperty':
-            result += ' Double';
-            if (mm.defaultValue) {
-                const doubleString = mm.defaultValue.toFixed(Math.max(1, (mm.defaultValue.toString().split('.')[1] || []).length));
-
-                defaultString += ` default=${doubleString}`;
-            }
-            if (mm.validator) {
-                const lowerString = mm.validator.lower ? mm.validator.lower : '';
-                const upperString = mm.validator.upper ? mm.validator.upper : '';
-                validatorString += ` range=[${lowerString},${upperString}]`;
-            }
-            break;
-        case 'concerto.metamodel.IntegerProperty':
-            result += ' Integer';
-            if (mm.defaultValue) {
-                defaultString += ` default=${mm.defaultValue.toString()}`;
-            }
-            if (mm.validator) {
-                const lowerString = mm.validator.lower ? mm.validator.lower : '';
-                const upperString = mm.validator.upper ? mm.validator.upper : '';
-                validatorString += ` range=[${lowerString},${upperString}]`;
-            }
-            break;
-        case 'concerto.metamodel.LongProperty':
-            result += ' Long';
-            if (mm.defaultValue) {
-                defaultString += ` default=${mm.defaultValue.toString()}`;
-            }
-            if (mm.validator) {
-                const lowerString = mm.validator.lower ? mm.validator.lower : '';
-                const upperString = mm.validator.upper ? mm.validator.upper : '';
-                validatorString += ` range=[${lowerString},${upperString}]`;
-            }
-            break;
-        case 'concerto.metamodel.StringProperty':
-            result += ' String';
-            if (mm.defaultValue) {
-                defaultString += ` default="${mm.defaultValue}"`;
-            }
-            if (mm.validator) {
-                validatorString += ` regex=/${mm.validator.pattern}/${mm.validator.flags}`;
-            }
-            break;
-        case 'concerto.metamodel.ObjectProperty':
-            result += ` ${mm.type.name}`;
-            if (mm.defaultValue) {
-                defaultString += ` default="${mm.defaultValue}"`;
-            }
-            break;
-        case 'concerto.metamodel.RelationshipProperty':
-            result += ` ${mm.type.name}`;
-            break;
-        }
-        if (mm.isArray) {
-            result += '[]';
-        }
-        result += ` ${mm.name}`;
-        if (mm.isOptional) {
-            result += ' optional';
-        }
-        result += defaultString;
-        result += validatorString;
-        return result;
-    }
-
-    /**
-     * Create a declaration string from a metamodel
-     * @param {object} mm - the metamodel
-     * @return {string} the string for that declaration
-     */
-    static declFromMetaModel(mm) {
-        let result = '';
-        if (mm.decorators) {
-            result += MetaModel.decoratorsFromMetaModel(mm.decorators, '');
-        }
-
-        if (mm.isAbstract) {
-            result += 'abstract ';
-        }
-        switch (mm.$class) {
-        case 'concerto.metamodel.AssetDeclaration':
-            result += `asset ${mm.name} `;
-            break;
-        case 'concerto.metamodel.ConceptDeclaration':
-            result += `concept ${mm.name} `;
-            break;
-        case 'concerto.metamodel.EventDeclaration':
-            result += `event ${mm.name} `;
-            break;
-        case 'concerto.metamodel.ParticipantDeclaration':
-            result += `participant ${mm.name} `;
-            break;
-        case 'concerto.metamodel.TransactionDeclaration':
-            result += `transaction ${mm.name} `;
-            break;
-        case 'concerto.metamodel.EnumDeclaration':
-            result += `enum ${mm.name} `;
-            break;
-        }
-        if (mm.superType) {
-            result += `extends ${mm.superType.name} `;
-        }
-        // XXX Needs to be fixed to support `identified`
-        if (mm.identified) {
-            if (mm.identified.$class === 'concerto.metamodel.IdentifiedBy') {
-                result += `identified by ${mm.identified.name} `;
-            } else {
-                result += 'identified ';
-            }
-        }
-        result += '{';
-        mm.properties.forEach((property) => {
-            result += `\n  ${MetaModel.propertyFromMetaModel(property)}`;
-        });
-        result += '\n}';
-        return result;
-    }
-
-    /**
-     * Create a model string from a metamodel
-     * @param {object} metaModel - the metamodel
-     * @param {boolean} [validate] - whether to perform validation
-     * @return {string} the string for that model
-     */
-    static ctoFromMetaModel(metaModel, validate = true) {
-        // First, validate the JSON metaModel
-        const mm = validate ? MetaModel.validateMetaModel(metaModel) : metaModel;
-
-        let result = '';
-        result += `namespace ${mm.namespace}`;
-        if (mm.imports && mm.imports.length > 0) {
-            result += '\n';
-            mm.imports.forEach((imp) => {
-                let name = '*';
-                if (imp.$class === 'concerto.metamodel.ImportType') {
-                    name = imp.name;
-                }
-                result += `\nimport ${imp.namespace}.${name}`;
-                if (imp.uri) {
-                    result += ` from ${imp.uri}`;
-                }
-            });
-        }
-        if (mm.declarations && mm.declarations.length > 0) {
-            mm.declarations.forEach((decl) => {
-                result += `\n\n${MetaModel.declFromMetaModel(decl)}`;
-            });
-        }
-        return result;
-    }
-
     /**
      * Import metamodel to a model manager
      * @param {object} metaModel - the metamodel
      * @param {boolean} [validate] - whether to perform validation
      * @return {object} the metamodel for this model manager
      */
-    static modelManagerFromMetaModel(metaModel, validate) {
+    static modelManagerFromMetaModel(metaModel, validate = true) {
         // First, validate the JSON metaModel
         const mm = validate ? MetaModel.validateMetaModel(metaModel) : metaModel;
 
         const modelManager = new ModelManager();
 
         mm.models.forEach((mm) => {
-            const cto = MetaModel.ctoFromMetaModel(mm, false); // No need to re-validate
+            const cto = Printer.toCTO(mm); // No need to re-validate
             modelManager.addModelFile(cto, null, false);
         });
 
         modelManager.validateModelFiles();
         return modelManager;
     }
-
-    /**
-     * Export metamodel from a model string
-     * @param {string} model - the string for the model
-     * @param {boolean} [validate] - whether to perform validation
-     * @return {object} the metamodel for this model
-     */
-    static ctoToMetaModel(model, validate) {
-        return parser.parse(model);
-    }
-
-    /**
-     * Export metamodel from a model string and resolve names
-     * @param {*} modelManager - the model manager
-     * @param {string} model - the string for the model
-     * @param {boolean} [validate] - whether to perform validation
-     * @return {object} the metamodel for this model
-     */
-    static ctoToMetaModelAndResolve(modelManager, model, validate) {
-        const metaModel = parser.parse(model);
-        const result = MetaModel.resolveMetaModel(modelManager, metaModel);
-        return result;
-    }
 }
 
 module.exports = MetaModel;

package/lib/introspect/modelfile.js

@@ -16,7 +16,6 @@
 
 const packageJson = require('../../package.json');
 const semver = require('semver');
-const parser = require('./parser');
 const AssetDeclaration = require('./assetdeclaration');
 const EnumDeclaration = require('./enumdeclaration');
 const ConceptDeclaration = require('./conceptdeclaration');
@@ -27,6 +26,7 @@ const IllegalModelException = require('./illegalmodelexception');
 const ParseException = require('./parseexception');
 const ModelUtil = require('../modelutil');
 const Globalize = require('../globalize');
+const { Parser } = require('@accordproject/concerto-cto');
 
 /**
  * Class representing a Model File. A Model File contains a single namespace
@@ -72,8 +72,7 @@ class ModelFile {
         }
 
         try {
-            this.ast = parser.parse(definitions);
-            // console.log(`AST ${JSON.stringify(this.ast, null, 2)}`);
+            this.ast = Parser.parse(definitions);
         }
         catch(err) {
             if(err.location && err.location.start) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@accordproject/concerto-core",
-  "version": "1.2.2-20211124164813",
+  "version": "1.2.2-20211124205408",
   "description": "Core Implementation for the Concerto Modeling Language",
   "homepage": "https://github.com/accordproject/concerto",
   "engines": {
@@ -10,7 +10,6 @@
   "main": "index.js",
   "typings": "types/index.d.ts",
   "scripts": {
-    "prepare": "peggy ./lib/introspect/parser.pegjs",
     "pretest": "npm run lint",
     "lint": "eslint .",
     "postlint": "npm run licchk",
@@ -59,6 +58,7 @@
     "yargs": "17.1.0"
   },
   "dependencies": {
+    "@accordproject/concerto-cto": "1.2.2-20211124205408",
     "@supercharge/promise-pool": "1.7.0",
     "axios": "0.23.0",
     "colors": "1.4.0",
@@ -83,7 +83,6 @@
       "coverage",
       "index.d.ts",
       "./system",
-      "./introspect/parser.js",
       "LICENSE",
       "node_modules",
       ".nyc-output",
@@ -128,11 +127,7 @@
     "include": [
       "lib/**/*.js"
     ],
-    "exclude": [
-      "lib/codegen/parsejs.js",
-      "lib/codegen/javascriptparser.js",
-      "lib/introspect/parser.js"
-    ],
+    "exclude": [],
     "all": true,
     "check-coverage": true,
     "statements": 98,

package/types/lib/introspect/metamodel.d.ts

@@ -4,10 +4,9 @@ export = MetaModel;
  */
 declare class MetaModel {
     /**
-     * Returns the metamodel CTO
-     * @returns {string} the metamodel as a CTO string
+     * The metamodel itself, as a CTO string
      */
-    static getMetaModelCto(): string;
+    static metaModelCto: string;
     /**
      * Create a metamodel manager (for validation against the metamodel)
      * @return {*} the metamodel manager

package/types/lib/modelutil.d.ts

@@ -14,6 +14,29 @@ declare class ModelUtil {
      * @private
      */
     private static getShortName;
+    /**
+     * Returns true if the specified name is a wildcard
+     * @param {string} fqn - the source string
+     * @return {boolean} true if the specified name is a wildcard
+     * @private
+     */
+    private static isWildcardName;
+    /**
+     * Returns true if the specified name is a recusive wildcard
+     * @param {string} fqn - the source string
+     * @return {boolean} true if the specified name is a recusive wildcard
+     * @private
+     */
+    private static isRecursiveWildcardName;
+    /**
+     * Returns true if a type matches the required fully qualified name. The required
+     * name may be a wildcard or recursive wildcard
+     * @param {Typed} type - the type to test
+     * @param {string} fqn - required fully qualified name
+     * @return {boolean} true if the specified type and namespace match
+     * @private
+     */
+    private static isMatchingType;
     /**
      * Returns the namespace for a the fully qualified name of a type
      * @param {string} fqn - the fully qualified identifier of a type
@@ -22,13 +45,6 @@ declare class ModelUtil {
      * @private
      */
     private static getNamespace;
-    /**
-     * Return the fully qualified name for an import
-     * @param {object} imp - the import
-     * @return {string} - the fully qualified name for that import
-     * @private
-     */
-    private static importFullyQualifiedName;
     /**
      * Returns true if the type is a primitive type
      * @param {string} typeName - the name of the type