@accordproject/concerto-core 3.1.0 → 3.2.0

package/dist/concerto-core.js.LICENSE.txt

@@ -1,5 +1,5 @@
 /*!
- * Concerto v3.1.0
+ * Concerto v3.2.0
  *         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

package/lib/introspect/classdeclaration.js

@@ -239,7 +239,12 @@ class ClassDeclaration extends Decorated {
                 }), this.modelFile, this.ast.location);
             } else {
                 // check that identifiers are strings
-                if (idField.getType() !== 'String') {
+                const isPrimitiveString = idField.getType() === 'String';
+                const modelFile = idField.getParent().getModelFile();
+                const declaration = modelFile.getType(idField.getType());
+                const isScalarString = declaration !== null && declaration.isScalarDeclaration?.() && declaration.getType?.() === 'String';
+
+                if (!isPrimitiveString && !isScalarString) {
                     let formatter = Globalize('en').messageFormatter('classdeclaration-validate-identifiernotstring');
                     throw new IllegalModelException(formatter({
                         'class': this.name,

package/lib/introspect/field.js

@@ -14,6 +14,8 @@
 
 'use strict';
 
+const { MetaModelNamespace } = require('@accordproject/concerto-metamodel');
+
 const Property = require('./property');
 const NumberValidator = require('./numbervalidator');
 const StringValidator = require('./stringvalidator');
@@ -46,6 +48,7 @@ class Field extends Property {
      */
     constructor(parent, ast) {
         super(parent, ast);
+        this.scalarField = null; // cache scalar field
     }
 
     /**
@@ -58,22 +61,28 @@ class Field extends Property {
 
         this.validator = null;
 
-        switch(this.getType()) {
+        switch (this.getType()) {
         case 'Integer':
         case 'Double':
         case 'Long':
-            if(this.ast.validator) {
-                this.validator = new NumberValidator(this, this.ast.validator);
+            if (this.ast.validator) {
+                this.validator = new NumberValidator(
+                    this,
+                    this.ast.validator
+                );
             }
             break;
         case 'String':
-            if(this.ast.validator) {
-                this.validator = new StringValidator(this, this.ast.validator);
+            if (this.ast.validator) {
+                this.validator = new StringValidator(
+                    this,
+                    this.ast.validator
+                );
             }
             break;
         }
 
-        if(this.ast.defaultValue) {
+        if (this.ast.defaultValue) {
             this.defaultValue = this.ast.defaultValue;
         } else {
             this.defaultValue = null;
@@ -93,10 +102,9 @@ class Field extends Property {
      * @return {string | number} the default value for the field or null
      */
     getDefaultValue() {
-        if(this.defaultValue) {
+        if (this.defaultValue) {
             return this.defaultValue;
-        }
-        else {
+        } else {
             return null;
         }
     }
@@ -106,7 +114,17 @@ class Field extends Property {
      * @return {String} the string version of the property.
      */
     toString() {
-        return 'Field {name=' + this.name + ', type=' + this.getFullyQualifiedTypeName() + ', array=' + this.array + ', optional=' + this.optional +'}';
+        return (
+            'Field {name=' +
+            this.name +
+            ', type=' +
+            this.getFullyQualifiedTypeName() +
+            ', array=' +
+            this.array +
+            ', optional=' +
+            this.optional +
+            '}'
+        );
     }
 
     /**
@@ -117,6 +135,69 @@ class Field extends Property {
     isField() {
         return true;
     }
+
+    /**
+     * Returns true if the field's type is a scalar
+     * @returns {boolean} true if the field is a scalar type
+     */
+    isTypeScalar() {
+        if (this.isPrimitive()) {
+            return false;
+        } else {
+            const type = this.getParent()
+                .getModelFile()
+                .getType(this.getType());
+            return type.isScalarDeclaration?.();
+        }
+    }
+
+    /**
+     * Unboxes a field that references a scalar type to an
+     * underlying Field definition.
+     * @throws {Error} throws an error if this field is not a scalar type.
+     * @returns {Field} the primitive field for this scalar
+     */
+    getScalarField() {
+        if(this.scalarField) {
+            return this.scalarField;
+        }
+        if (!this.isTypeScalar()) {
+            throw new Error(`Field ${this.name} is not a scalar property.`);
+        }
+        const type = this.getParent().getModelFile().getType(this.getType());
+        const fieldAst = JSON.parse(JSON.stringify(type.ast));
+
+        switch (type.ast.$class) {
+        case `${MetaModelNamespace}.StringScalar`:
+            fieldAst.$class = `${MetaModelNamespace}.StringProperty`;
+            break;
+        case `${MetaModelNamespace}.BooleanScalar`:
+            fieldAst.$class = `${MetaModelNamespace}.BooleanProperty`;
+            break;
+
+        case `${MetaModelNamespace}.DateTimeScalar`:
+            fieldAst.$class = `${MetaModelNamespace}.DateTimeProperty`;
+            break;
+
+        case `${MetaModelNamespace}.DoubleScalar`:
+            fieldAst.$class = `${MetaModelNamespace}.DoubleProperty`;
+            break;
+
+        case `${MetaModelNamespace}.IntegerScalar`:
+            fieldAst.$class = `${MetaModelNamespace}.IntegerProperty`;
+            break;
+
+        case `${MetaModelNamespace}.LongScalar`:
+            fieldAst.$class = `${MetaModelNamespace}.LongProperty`;
+            break;
+        default:
+            throw new Error(`Unrecognized scalar type ${type.ast.$class}`);
+        }
+
+        fieldAst.name = this.ast.name;
+        this.scalarField = new Field(this.getParent(), fieldAst);
+        return this.scalarField;
+    }
 }
 
 module.exports = Field;

package/lib/introspect/introspector.js

@@ -59,7 +59,11 @@ class Introspector {
         const modelFiles = this.modelManager.getModelFiles();
         for(let n=0; n < modelFiles.length; n++) {
             const modelFile = modelFiles[n];
-            result = result.concat(modelFile.getAllDeclarations());
+            result = result.concat(
+                modelFile.getAllDeclarations()
+                    .filter(declaration => !declaration.isScalarDeclaration?.()
+                    )
+            );
         }
         return result;
     }

package/lib/introspect/modelfile.js

@@ -21,6 +21,7 @@ const semver = require('semver');
 const AssetDeclaration = require('./assetdeclaration');
 const EnumDeclaration = require('./enumdeclaration');
 const ConceptDeclaration = require('./conceptdeclaration');
+const ScalarDeclaration = require('./scalardeclaration');
 const ParticipantDeclaration = require('./participantdeclaration');
 const TransactionDeclaration = require('./transactiondeclaration');
 const EventDeclaration = require('./eventdeclaration');
@@ -61,7 +62,7 @@ class ModelFile extends Decorated {
         this.modelManager = modelManager;
         this.external = false;
         this.declarations = [];
-        this.localTypes = new Map();
+        this.localTypes = null;
         this.imports = [];
         this.importShortNames = new Map();
         this.importWildcardNamespaces = [];
@@ -92,13 +93,13 @@ class ModelFile extends Decorated {
 
         // Set up the decorators.
         this.process();
-
         // Populate from the AST
         this.fromAst(this.ast);
         // Check version compatibility
         this.isCompatibleVersion();
 
         // Now build local types from Declarations
+        this.localTypes = new Map();
         for(let index in this.declarations) {
             let classDeclaration = this.declarations[index];
             let localType = this.getNamespace() + '.' + classDeclaration.getName();
@@ -451,6 +452,10 @@ class ModelFile extends Decorated {
      * @return {ClassDeclaration} the ClassDeclaration, or null if the type does not exist
      */
     getLocalType(type) {
+        if(!this.localTypes) {
+            throw new Error('Internal error: local types are not yet initialized. Do not try to resolve types inside `process`.');
+        }
+
         if(!type.startsWith(this.getNamespace())) {
             type = this.getNamespace() + '.' + type;
         }
@@ -583,19 +588,28 @@ class ModelFile extends Decorated {
         return this.getDeclarations(EnumDeclaration);
     }
 
+    /**
+     * Get the ScalarDeclaration defined in this ModelFile
+     * @return {ScalarDeclaration[]} the ScalarDeclaration defined in the model file
+     */
+    getScalarDeclarations() {
+        return this.getDeclarations(ScalarDeclaration);
+    }
+
     /**
      * Get the instances of a given type in this ModelFile
      * @param {Function} type - the type of the declaration
-     * @return {ClassDeclaration[]} the ClassDeclaration defined in the model file
+     * @return {Object[]} the ClassDeclaration defined in the model file
      */
     getDeclarations(type) {
         let result = [];
         for(let n=0; n < this.declarations.length; n++) {
-            let classDeclaration = this.declarations[n];
-            if(classDeclaration instanceof type) {
-                result.push(classDeclaration);
+            let declaration = this.declarations[n];
+            if(declaration instanceof type) {
+                result.push(declaration);
             }
         }
+
         return result;
     }
 
@@ -760,6 +774,16 @@ class ModelFile extends Decorated {
             else if(thing.$class === `${MetaModelNamespace}.ConceptDeclaration`) {
                 this.declarations.push( new ConceptDeclaration(this, thing) );
             }
+            else if([
+                `${MetaModelNamespace}.BooleanScalar`,
+                `${MetaModelNamespace}.IntegerScalar`,
+                `${MetaModelNamespace}.LongScalar`,
+                `${MetaModelNamespace}.DoubleScalar`,
+                `${MetaModelNamespace}.StringScalar`,
+                `${MetaModelNamespace}.DateTimeScalar`,
+            ].includes(thing.$class)) {
+                this.declarations.push( new ScalarDeclaration(this, thing) );
+            }
             else {
                 let formatter = Globalize('en').messageFormatter('modelfile-constructor-unrecmodelelem');
 

package/lib/introspect/numbervalidator.js

@@ -22,6 +22,7 @@ const Validator = require('./validator');
 /* istanbul ignore next */
 if (global === undefined) {
     const Field = require('./field');
+    const ScalarDeclaration = require('./scalardeclaration');
 }
 /* eslint-enable no-unused-vars */
 
@@ -35,7 +36,7 @@ class NumberValidator extends Validator{
 
     /**
      * Create a NumberValidator.
-     * @param {Field} field - the field this validator is attached to
+     * @param {Object} field - the field or scalar declaration this validator is attached to
      * @param {Object} ast - The ast for the range defined as [lower,upper] (inclusive).
      *
      * @throws {IllegalModelException}

package/lib/introspect/property.js

@@ -88,24 +88,33 @@ class Property extends Decorated {
             throw new Error('No name for type ' + JSON.stringify(this.ast));
         }
 
-        if (this.ast.$class === `${MetaModelNamespace}.BooleanProperty`) {
+        switch (this.ast.$class) {
+        case `${MetaModelNamespace}.EnumProperty`:
+            break;
+        case `${MetaModelNamespace}.BooleanProperty`:
             this.type = 'Boolean';
-        } else if (this.ast.$class === `${MetaModelNamespace}.StringProperty`) {
-            this.type = 'String';
-        } else if (this.ast.$class === `${MetaModelNamespace}.IntegerProperty`) {
+            break;
+        case `${MetaModelNamespace}.DateTimeProperty`:
+            this.type = 'DateTime';
+            break;
+        case `${MetaModelNamespace}.DoubleProperty`:
+            this.type = 'Double';
+            break;
+        case `${MetaModelNamespace}.IntegerProperty`:
             this.type = 'Integer';
-        } else if (this.ast.$class === `${MetaModelNamespace}.LongProperty`) {
+            break;
+        case `${MetaModelNamespace}.LongProperty`:
             this.type = 'Long';
-        } else if (this.ast.$class === `${MetaModelNamespace}.DoubleProperty`) {
-            this.type = 'Double';
-        } else if (this.ast.$class === `${MetaModelNamespace}.DateTimeProperty`) {
-            this.type = 'DateTime';
-        } else if (this.ast.$class === `${MetaModelNamespace}.ObjectProperty`) {
+            break;
+        case `${MetaModelNamespace}.StringProperty`:
+            this.type = 'String';
+            break;
+        case `${MetaModelNamespace}.ObjectProperty`:
             this.type = this.ast.type ? this.ast.type.name : null;
-        } else if (this.ast.$class === `${MetaModelNamespace}.RelationshipProperty`) {
+            break;
+        case `${MetaModelNamespace}.RelationshipProperty`:
             this.type = this.ast.type.name;
-        } else {
-            this.type = null;
+            break;
         }
         this.array = false;
 
@@ -176,7 +185,6 @@ class Property extends Decorated {
         if(!modelFile) {
             throw new Error('Parent of property ' + this.name + ' does not have a ModelFile!');
         }
-
         const result = modelFile.getFullyQualifiedTypeName(this.type);
         if(!result) {
             throw new Error('Failed to find fully qualified type name for property ' + this.name + ' with type ' + this.type );

package/lib/introspect/scalardeclaration.js

@@ -0,0 +1,341 @@
+/*
+ * 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.
+ */
+
+'use strict';
+
+const { MetaModelNamespace } = require('@accordproject/concerto-metamodel');
+
+const Decorated = require('./decorated');
+const IllegalModelException = require('./illegalmodelexception');
+const ModelUtil = require('../modelutil');
+const NumberValidator = require('./numbervalidator');
+const StringValidator = require('./stringvalidator');
+
+// Types needed for TypeScript generation.
+/* eslint-disable no-unused-vars */
+/* istanbul ignore next */
+if (global === undefined) {
+    const ModelFile = require('./modelfile');
+    const Validator = require('./validator');
+}
+/* eslint-enable no-unused-vars */
+
+/**
+ * ScalarDeclaration defines the structure (model/schema) of composite data.
+ * It is composed of a set of Properties, may have an identifying field, and may
+ * have a super-type.
+ * A ScalarDeclaration is conceptually owned by a ModelFile which
+ * defines all the classes that are part of a namespace.
+ *
+ * @abstract
+ * @class
+ * @memberof module:concerto-core
+ */
+class ScalarDeclaration extends Decorated {
+    /**
+     * Create a ScalarDeclaration from an Abstract Syntax Tree. The AST is the
+     * result of parsing.
+     *
+     * @param {ModelFile} modelFile - the ModelFile for this class
+     * @param {Object} ast - the AST created by the parser
+     * @throws {IllegalModelException}
+     */
+    constructor(modelFile, ast) {
+        super(ast);
+        this.modelFile = modelFile;
+        this.process();
+    }
+
+    /**
+     * Returns the ModelFile that defines this class.
+     *
+     * @public
+     * @return {ModelFile} the owning ModelFile
+     */
+    getModelFile() {
+        return this.modelFile;
+    }
+
+    /**
+     * Process the AST and build the model
+     *
+     * @throws {IllegalModelException}
+     * @private
+     */
+    process() {
+        super.process();
+
+        this.name = this.ast.name;
+        this.superType = null;
+        this.superTypeDeclaration = null;
+        this.idField = null;
+        this.timestamped = false;
+        this.abstract = false;
+        this.validator = null;
+
+        if (this.ast.$class === `${MetaModelNamespace}.BooleanScalar`) {
+            this.type = 'Boolean';
+        } else if (this.ast.$class === `${MetaModelNamespace}.IntegerScalar`) {
+            this.type = 'Integer';
+        } else if (this.ast.$class === `${MetaModelNamespace}.LongScalar`) {
+            this.type = 'Long';
+        } else if (this.ast.$class === `${MetaModelNamespace}.DoubleScalar`) {
+            this.type = 'Double';
+        } else if (this.ast.$class === `${MetaModelNamespace}.StringScalar`) {
+            this.type = 'String';
+        } else if (this.ast.$class === `${MetaModelNamespace}.DateTimeScalar`) {
+            this.type = 'DateTime';
+        } else {
+            this.type = null;
+        }
+
+        switch(this.getType()) {
+        case 'Integer':
+        case 'Double':
+        case 'Long':
+            if(this.ast.validator) {
+                this.validator = new NumberValidator(this, this.ast.validator);
+            }
+            break;
+        case 'String':
+            if(this.ast.validator) {
+                this.validator = new StringValidator(this, this.ast.validator);
+            }
+            break;
+        }
+
+        if(this.ast.defaultValue) {
+            this.defaultValue = this.ast.defaultValue;
+        } else {
+            this.defaultValue = null;
+        }
+
+        this.fqn = ModelUtil.getFullyQualifiedName(this.modelFile.getNamespace(), this.name);
+    }
+
+    /**
+     * Semantic validation of the structure of this class. Subclasses should
+     * override this method to impose additional semantic constraints on the
+     * contents/relations of fields.
+     *
+     * @throws {IllegalModelException}
+     * @protected
+     */
+    validate() {
+        super.validate();
+
+        const declarations = this.getModelFile().getAllDeclarations();
+        for (let n = 0; n < declarations.length; n++) {
+            let declaration = declarations[n];
+
+            // check we don't have an asset with the same name
+            for (let i = n + 1; i < declarations.length; i++) {
+                let otherDeclaration = declarations[i];
+                if (declaration.getFullyQualifiedName() === otherDeclaration.getFullyQualifiedName()) {
+                    throw new IllegalModelException(`Duplicate class name ${declaration.getName()}`);
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns the short name of a class. This name does not include the
+     * namespace from the owning ModelFile.
+     *
+     * @return {string} the short name of this class
+     */
+    getName() {
+        return this.name;
+    }
+
+    /**
+     * Return the namespace of this class.
+     * @return {string} namespace - a namespace.
+     */
+    getNamespace() {
+        return this.modelFile.getNamespace();
+    }
+
+    /**
+     * Returns the fully qualified name of this class.
+     * The name will include the namespace if present.
+     *
+     * @return {string} the fully-qualified name of this class
+     */
+    getFullyQualifiedName() {
+        return this.fqn;
+    }
+
+    /**
+     * Returns false as scalars are never identified.
+     * @returns {Boolean} false as scalars are never identified
+     */
+    isIdentified() {
+        return false;
+    }
+
+    /**
+     * Returns false as scalars are never identified.
+     * @returns {Boolean} false as scalars are never identified
+     */
+    isSystemIdentified() {
+        return false;
+    }
+
+    /**
+     * Returns null as scalars are never identified.
+     * @return {null} null, as scalars are never identified
+     */
+    getIdentifierFieldName() {
+        return null;
+    }
+
+
+    /**
+     * Returns the FQN of the super type for this class or null if this
+     * class does not have a super type.
+     *
+     * @return {string} the FQN name of the super type or null
+     */
+    getType() {
+        return this.type;
+    }
+
+    /**
+     * Throws an error as scalars do not have supertypes.
+     */
+    getSuperType() {
+        throw new Error('Scalars do not have super types.');
+    }
+
+    /**
+     * Get the super type class declaration for this class.
+     * @return {ScalarDeclaration | null} the super type declaration, or null if there is no super type.
+     */
+    getSuperTypeDeclaration() {
+        return null;
+    }
+
+    /**
+     * Returns the validator string for this scalar definition
+     * @return {Validator} the validator for the field or null
+     */
+    getValidator() {
+        return this.validator;
+    }
+
+    /**
+       * Returns the default value for the field or null
+       * @return {string | number | null} the default value for the field or null
+       */
+    getDefaultValue() {
+        if(this.defaultValue) {
+            return this.defaultValue;
+        }
+        else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the string representation of this class
+     * @return {String} the string representation of the class
+     */
+    toString() {
+        return 'ScalarDeclaration {id=' + this.getFullyQualifiedName() + '}';
+    }
+
+    /**
+     * Returns true if this class is abstract.
+     *
+     * @return {boolean} true if the class is abstract
+     */
+    isAbstract() {
+        return true;
+    }
+
+    /**
+     * Returns true if this class is the definition of an asset.
+     *
+     * @return {boolean} true if the class is an asset
+     */
+    isAsset() {
+        return false;
+    }
+
+    /**
+     * Returns true if this class is the definition of a participant.
+     *
+     * @return {boolean} true if the class is a participant
+     */
+    isParticipant() {
+        return false;
+    }
+
+    /**
+     * Returns true if this class is the definition of a transaction.
+     *
+     * @return {boolean} true if the class is a transaction
+     */
+    isTransaction() {
+        return false;
+    }
+
+    /**
+     * Returns true if this class is the definition of an event.
+     *
+     * @return {boolean} true if the class is an event
+     */
+    isEvent() {
+        return false;
+    }
+
+    /**
+     * Returns true if this class is the definition of a concept.
+     *
+     * @return {boolean} true if the class is a concept
+     */
+    isConcept() {
+        return false;
+    }
+
+    /**
+     * Returns true if this class is the definition of an enum.
+     *
+     * @return {boolean} true if the class is an enum
+     */
+    isEnum() {
+        return false;
+    }
+
+    /**
+     * Returns true if this class is the definition of a class declaration.
+     *
+     * @return {boolean} true if the class is a class
+     */
+    isClassDeclaration() {
+        return false;
+    }
+
+    /**
+     * Returns true if this class is the definition of a scalar declaration.
+     *
+     * @return {boolean} true if the class is a scalar
+     */
+    isScalarDeclaration() {
+        return true;
+    }
+}
+
+module.exports = ScalarDeclaration;