@accordproject/concerto-core 1.2.2-20220112170439 → 1.2.2-20220222214455

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 {fb3110c45d21beac59b99bba03d41197} 2021-11-24
+Version 1.2.2 {859dc5db772867c4591ed1fd70b8f840} 2021-11-24
 - 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

@@ -15,201 +15,22 @@
 'use strict';
 
 const Printer = require('@accordproject/concerto-cto').Printer;
+const MetaModelUtil = require('@accordproject/concerto-metamodel').MetaModelUtil;
+
 const ModelManager = require('../modelmanager');
 const Factory = require('../factory');
 const Serializer = require('../serializer');
 
-/**
- * The metamodel itself, as a CTO string
- */
-const metaModelCto = `namespace concerto.metamodel
-
-concept Position {
-  o Integer line
-  o Integer column
-  o Integer offset
-}
-
-concept Range {
-  o Position start
-  o Position end
-  o String source optional
-}
-
-concept TypeIdentifier {
-  o String name
-  o String namespace optional
-}
-
-abstract concept DecoratorLiteral {
-  o Range location optional
-}
-
-concept DecoratorString extends DecoratorLiteral {
-  o String value
-}
-
-concept DecoratorNumber extends DecoratorLiteral {
-  o Double value
-}
-
-concept DecoratorBoolean extends DecoratorLiteral {
-  o Boolean value
-}
-
-concept DecoratorTypeReference extends DecoratorLiteral {
-  o TypeIdentifier type
-  o Boolean isArray default=false
-}
-
-concept Decorator {
-  o String name
-  o DecoratorLiteral[] arguments optional
-  o Range location optional
-}
-
-concept Identified {
-}
-
-concept IdentifiedBy extends Identified {
-  o String name
-}
-
-abstract concept Declaration {
-  o String name regex=/^(?!null|true|false)(\\p{Lu}|\\p{Ll}|\\p{Lt}|\\p{Lm}|\\p{Lo}|\\p{Nl}|\\$|_|\\\\u[0-9A-Fa-f]{4})(?:\\p{Lu}|\\p{Ll}|\\p{Lt}|\\p{Lm}|\\p{Lo}|\\p{Nl}|\\$|_|\\\\u[0-9A-Fa-f]{4}|\\p{Mn}|\\p{Mc}|\\p{Nd}|\\p{Pc}|\\u200C|\\u200D)*$/u
-  o Decorator[] decorators optional
-  o Range location optional
-}
-
-concept EnumDeclaration extends Declaration {
-  o EnumProperty[] properties
-}
-
-concept EnumProperty {
-  o String name regex=/^(?!null|true|false)(\\p{Lu}|\\p{Ll}|\\p{Lt}|\\p{Lm}|\\p{Lo}|\\p{Nl}|\\$|_|\\\\u[0-9A-Fa-f]{4})(?:\\p{Lu}|\\p{Ll}|\\p{Lt}|\\p{Lm}|\\p{Lo}|\\p{Nl}|\\$|_|\\\\u[0-9A-Fa-f]{4}|\\p{Mn}|\\p{Mc}|\\p{Nd}|\\p{Pc}|\\u200C|\\u200D)*$/u
-  o Decorator[] decorators optional
-  o Range location optional
-}
-
-concept ConceptDeclaration extends Declaration {
-  o Boolean isAbstract default=false
-  o Identified identified optional
-  o TypeIdentifier superType optional
-  o Property[] properties
-}
-
-concept AssetDeclaration extends ConceptDeclaration {
-}
-
-concept ParticipantDeclaration extends ConceptDeclaration {
-}
-
-concept TransactionDeclaration extends ConceptDeclaration {
-}
-
-concept EventDeclaration extends ConceptDeclaration {
-}
-
-abstract concept Property {
-  o String name regex=/^(?!null|true|false)(\\p{Lu}|\\p{Ll}|\\p{Lt}|\\p{Lm}|\\p{Lo}|\\p{Nl}|\\$|_|\\\\u[0-9A-Fa-f]{4})(?:\\p{Lu}|\\p{Ll}|\\p{Lt}|\\p{Lm}|\\p{Lo}|\\p{Nl}|\\$|_|\\\\u[0-9A-Fa-f]{4}|\\p{Mn}|\\p{Mc}|\\p{Nd}|\\p{Pc}|\\u200C|\\u200D)*$/u
-  o Boolean isArray default=false
-  o Boolean isOptional default=false
-  o Decorator[] decorators optional
-  o Range location optional
-}
-
-concept RelationshipProperty extends Property {
-  o TypeIdentifier type
-}
-
-concept ObjectProperty extends Property {
-  o String defaultValue optional
-  o TypeIdentifier type
-}
-
-concept BooleanProperty extends Property {
-  o Boolean defaultValue optional
-}
-
-concept DateTimeProperty extends Property {
-}
-
-concept StringProperty extends Property {
-  o String defaultValue optional
-  o StringRegexValidator validator optional
-}
-
-concept StringRegexValidator {
-  o String pattern
-  o String flags
-}
-
-concept DoubleProperty extends Property {
-  o Double defaultValue optional
-  o DoubleDomainValidator validator optional
-}
-
-concept DoubleDomainValidator {
-  o Double lower optional
-  o Double upper optional
-}
-
-concept IntegerProperty extends Property {
-  o Integer defaultValue optional
-  o IntegerDomainValidator validator optional
-}
-
-concept IntegerDomainValidator {
-  o Integer lower optional
-  o Integer upper optional
-}
-
-concept LongProperty extends Property {
-  o Long defaultValue optional
-  o LongDomainValidator validator optional
-}
-
-concept LongDomainValidator {
-  o Long lower optional
-  o Long upper optional
-}
-
-abstract concept Import {
-  o String namespace
-  o String uri optional
-}
-
-concept ImportAll extends Import {
-}
-
-concept ImportType extends Import {
-  o String name
-}
-
-concept Model {
-  o String namespace
-  o String sourceUri optional
-  o String concertoVersion optional
-  o Import[] imports optional
-  o Declaration[] declarations optional
-}
-
-concept Models {
-  o Model[] 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;
+        return MetaModelUtil.metaModelCto;
     }
 
     /**
@@ -218,7 +39,7 @@ class MetaModel {
      */
     static createMetaModelManager() {
         const metaModelManager = new ModelManager();
-        metaModelManager.addModelFile(metaModelCto, 'concerto.metamodel');
+        metaModelManager.addModelFile(MetaModel.getMetaModelCto(), 'concerto.metamodel');
         return metaModelManager;
     }
 
@@ -236,134 +57,6 @@ class MetaModel {
         return serializer.toJSON(object);
     }
 
-    /**
-     * Create a name resolution table
-     * @param {*} modelManager - the model manager
-     * @param {object} metaModel - the metamodel (JSON)
-     * @return {object} mapping from a name to its namespace
-     */
-    static createNameTable(modelManager, metaModel) {
-        const table = {
-            'Concept': 'concerto',
-            'Asset': 'concerto',
-            'Participant': 'concerto',
-            'Transaction ': 'concerto',
-            'Event': 'concerto',
-        };
-
-        // First list the imported names in order (overriding as we go along)
-        const imports = metaModel.imports;
-        imports.forEach((imp) => {
-            const namespace = imp.namespace;
-            const modelFile = modelManager.getModelFile(namespace);
-            if (imp.$class === 'concerto.metamodel.ImportType') {
-                if (!modelFile.getLocalType(imp.name)) {
-                    throw new Error(`Declaration ${imp.name} in namespace ${namespace} not found`);
-                }
-                table[imp.name] = namespace;
-            } else {
-                const decls = modelFile.getAllDeclarations();
-                decls.forEach((decl) => {
-                    table[decl.getName()] = namespace;
-                });
-            }
-        });
-
-        // Then add the names local to this metaModel (overriding as we go along)
-        if (metaModel.declarations) {
-            metaModel.declarations.forEach((decl) => {
-                table[decl.name] = metaModel.namespace;
-            });
-        }
-
-        return table;
-    }
-
-    /**
-     * Resolve a name using the name table
-     * @param {string} name - the name of the type to resolve
-     * @param {object} table - the name table
-     * @return {string} the namespace for that name
-     */
-    static resolveName(name, table) {
-        if (!table[name]) {
-            throw new Error(`Name ${name} not found`);
-        }
-        return table[name];
-    }
-
-    /**
-     * Name resolution for metamodel
-     * @param {object} metaModel - the metamodel (JSON)
-     * @param {object} table - the name table
-     * @return {object} the metamodel with fully qualified names
-     */
-    static resolveTypeNames(metaModel, table) {
-        switch (metaModel.$class) {
-        case 'concerto.metamodel.Model': {
-            if (metaModel.declarations) {
-                metaModel.declarations.forEach((decl) => {
-                    MetaModel.resolveTypeNames(decl, table);
-                });
-            }
-        }
-            break;
-        case 'concerto.metamodel.AssetDeclaration':
-        case 'concerto.metamodel.ConceptDeclaration':
-        case 'concerto.metamodel.EventDeclaration':
-        case 'concerto.metamodel.TransactionDeclaration':
-        case 'concerto.metamodel.ParticipantDeclaration': {
-            if (metaModel.superType) {
-                const name = metaModel.superType.name;
-                metaModel.superType.namespace = MetaModel.resolveName(name, table);
-            }
-            metaModel.properties.forEach((property) => {
-                MetaModel.resolveTypeNames(property, table);
-            });
-            if (metaModel.decorators) {
-                metaModel.decorators.forEach((decorator) => {
-                    MetaModel.resolveTypeNames(decorator, table);
-                });
-            }
-        }
-            break;
-        case 'concerto.metamodel.EnumDeclaration': {
-            if (metaModel.decorators) {
-                metaModel.decorators.forEach((decorator) => {
-                    MetaModel.resolveTypeNames(decorator, table);
-                });
-            }
-        }
-            break;
-        case 'concerto.metamodel.EnumProperty':
-        case 'concerto.metamodel.ObjectProperty':
-        case 'concerto.metamodel.RelationshipProperty': {
-            const name = metaModel.type.name;
-            metaModel.type.namespace = MetaModel.resolveName(name, table);
-            if (metaModel.decorators) {
-                metaModel.decorators.forEach((decorator) => {
-                    MetaModel.resolveTypeNames(decorator, table);
-                });
-            }
-        }
-            break;
-        case 'concerto.metamodel.Decorator': {
-            if (metaModel.arguments) {
-                metaModel.arguments.forEach((argument) => {
-                    MetaModel.resolveTypeNames(argument, table);
-                });
-            }
-        }
-            break;
-        case 'concerto.metamodel.DecoratorTypeReference': {
-            const name = metaModel.type.name;
-            metaModel.type.namespace = MetaModel.resolveName(name, table);
-        }
-            break;
-        }
-        return metaModel;
-    }
-
     /**
      * Resolve the namespace for names in the metamodel
      * @param {object} modelManager - the ModelManager
@@ -375,11 +68,8 @@ class MetaModel {
         // 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;
+        const priorModels = modelManager.getAst();
+        return MetaModelUtil.resolveLocalNames(priorModels, mm);
     }
 
     /**

package/lib/introspect/numbervalidator.js

@@ -82,11 +82,11 @@ class NumberValidator extends Validator{
     validate(identifier, value) {
         if(value !== null) {
             if(this.lowerBound !== null && value < this.lowerBound) {
-                this.reportError(identifier, 'Value is outside lower bound ' + value);
+                this.reportError(identifier, `Value ${value} is outside lower bound ${this.lowerBound}`);
             }
 
             if(this.upperBound !== null && value > this.upperBound) {
-                this.reportError(identifier, 'Value is outside upper bound ' + value);
+                this.reportError(identifier, `Value ${value} is outside upper bound ${this.upperBound}`);
             }
         }
     }

package/lib/modelmanager.js

@@ -14,12 +14,11 @@
 
 'use strict';
 
-const fs = require('fs');
 const fsPath = require('path');
-const slash = require('slash');
 
 const DefaultFileLoader = require('@accordproject/concerto-util').DefaultFileLoader;
 const FileDownloader = require('@accordproject/concerto-util').FileDownloader;
+const ModelWriter = require('@accordproject/concerto-util').ModelWriter;
 const Parser = require('@accordproject/concerto-cto').Parser;
 
 const Factory = require('./factory');
@@ -283,7 +282,6 @@ abstract concept Event {}
      * @return {Promise} a promise when the download and update operation is completed.
      */
     async updateExternalModels(options, fileDownloader) {
-
         const NAME = 'updateExternalModels';
         debug(NAME, 'updateExternalModels', options);
 
@@ -300,29 +298,7 @@ abstract concept Event {}
             fileDownloader = new FileDownloader(new DefaultFileLoader(processFile), getExternalImports);
         }
 
-        const externalModelFiles = await fileDownloader.downloadExternalDependencies(this.getModelFiles(), options)
-            .catch(error => {
-                // If we're not able to download the latest dependencies, see whether the models all validate based on the available cached models.
-                if(error.code === 'MISSING_DEPENDENCY'){
-                    try {
-                        this.validateModelFiles();
-                        return [];
-                    } catch (validationError) {
-                        // The validation error tells us the first model that is missing from the model manager, but the dependency download
-                        // will fail at the first external model, regardless of whether there is already a local copy.
-                        // As a hint to the user we display the URL of the external model that can't be found.
-                        const modelFile = this.getModelFileByFileName(validationError.fileName);
-                        const namespaces = modelFile.getExternalImports();
-                        const missingNs = Object.keys(namespaces).find((ns) => validationError.shortMessage.includes(ns));
-                        const url = modelFile.getImportURI(missingNs);
-                        const err = new Error(`Unable to download external model dependency '${url}'`);
-                        err.code = 'MISSING_DEPENDENCY';
-                        throw err;
-                    }
-                } else {
-                    throw error;
-                }
-            });
+        const externalModelFiles = await fileDownloader.downloadExternalDependencies(this.getModelFiles(), options);
         const originalModelFiles = {};
         Object.assign(originalModelFiles, this.modelFiles);
 
@@ -356,22 +332,7 @@ abstract concept Event {}
      *  If true, external models are written to the file system. Defaults to true
      */
     writeModelsToFileSystem(path, options = {}) {
-        if(!path){
-            throw new Error('`path` is a required parameter of writeModelsToFileSystem');
-        }
-
-        const opts = Object.assign({
-            includeExternalModels: true,
-        }, options);
-
-        this.getModelFiles().forEach(function (file) {
-            if (file.isExternal() && !opts.includeExternalModels) {
-                return;
-            }
-            // Always assume file names have been normalized from `\` to `/`
-            const filename = slash(file.fileName).split('/').pop();
-            fs.writeFileSync(path + fsPath.sep + filename, file.definitions);
-        });
+        ModelWriter.writeModelsToFileSystem(this.getModelFiles(), path, options);
     }
 
     /**
@@ -639,6 +600,22 @@ abstract concept Event {}
         }
         return false;
     }
+
+    /**
+     * Get the full ast (metamodel instances) for a modelmanager
+     * @returns {*} the metamodel
+     */
+    getAst() {
+        const result = {
+            $class: 'concerto.metamodel.Models',
+            models: [],
+        };
+        const modelFiles = this.getModelFiles();
+        modelFiles.forEach((thisModelFile) => {
+            result.models.push(thisModelFile.getAst());
+        });
+        return result;
+    }
 }
 
 module.exports = ModelManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@accordproject/concerto-core",
-  "version": "1.2.2-20220112170439",
+  "version": "1.2.2-20220222214455",
   "description": "Core Implementation for the Concerto Modeling Language",
   "homepage": "https://github.com/accordproject/concerto",
   "engines": {
@@ -58,8 +58,9 @@
     "yargs": "17.1.0"
   },
   "dependencies": {
-    "@accordproject/concerto-cto": "1.2.2-20220112170439",
-    "@accordproject/concerto-util": "1.2.2-20220112170439",
+    "@accordproject/concerto-cto": "1.2.2-20220222214455",
+    "@accordproject/concerto-metamodel": "1.2.2-20220222214455",
+    "@accordproject/concerto-util": "1.2.2-20220222214455",
     "dayjs": "1.10.4",
     "debug": "4.3.1",
     "lorem-ipsum": "2.0.3",

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

@@ -19,27 +19,6 @@ declare class MetaModel {
      * @return {object} the validated metamodel in JSON
      */
     static validateMetaModel(input: object): object;
-    /**
-     * Create a name resolution table
-     * @param {*} modelManager - the model manager
-     * @param {object} metaModel - the metamodel (JSON)
-     * @return {object} mapping from a name to its namespace
-     */
-    static createNameTable(modelManager: any, metaModel: object): object;
-    /**
-     * Resolve a name using the name table
-     * @param {string} name - the name of the type to resolve
-     * @param {object} table - the name table
-     * @return {string} the namespace for that name
-     */
-    static resolveName(name: string, table: object): string;
-    /**
-     * Name resolution for metamodel
-     * @param {object} metaModel - the metamodel (JSON)
-     * @param {object} table - the name table
-     * @return {object} the metamodel with fully qualified names
-     */
-    static resolveTypeNames(metaModel: object, table: object): object;
     /**
      * Resolve the namespace for names in the metamodel
      * @param {object} modelManager - the ModelManager

package/types/lib/modelmanager.d.ts

@@ -244,6 +244,11 @@ declare class ModelManager {
      * qualified type name, false otherwise.
      */
     derivesFrom(fqt1: string, fqt2: string): boolean;
+    /**
+     * Get the full metamodel for a modelmanager
+     * @returns {*} the metamodel
+     */
+    getMetaModel(): any;
 }
 import Factory = require("./factory");
 import Serializer = require("./serializer");