feat(alias-import): update runtime classes to understand import aliasing

packages/concerto-core/api.txt

@@ -2,9 +2,10 @@ class AstModelManager extends BaseModelManager {
    + void constructor(object?) 
 }
 class BaseModelManager {
-   + void constructor(object?,boolean?,Object?,boolean?,boolean?,boolean?,processFile?) 
+   + void constructor(object?,boolean?,Object?,boolean?,boolean?,boolean?,boolean?,processFile?) 
    + boolean isModelManager() 
    + boolean isStrict() 
+   + boolean isAliasedTypeEnabled() 
    + Object accept(Object,Object) 
    + void validateModelFile(string|ModelFile,string?) throws IllegalModelException
    + Object addModelFile(ModelFile,string?,string?,boolean?) throws IllegalModelException

packages/concerto-core/changelog.txt

@@ -24,6 +24,9 @@
 # Note that the latest public API is documented using JSDocs and is available in api.txt.
 #
 
+Version 3.17.1 {fc7abec4765b5e1672dab7c6032dfdc3} 2024-06-21
+- Added 'enableAliasedType' option to BaseModelManager
+- Aliased types mapped to FQN in modelfile
 
 Version 3.16.7 {8f455df1e788c4994f423d6e236bee21} 2024-05-01
 - Added missing `strictQualifiedDateTimes` option to Serializer.fromJSON

packages/concerto-core/lib/basemodelmanager.js

@@ -82,6 +82,7 @@
      * @param {boolean} [options.metamodelValidation] - When true, modelfiles will be validated
      * @param {boolean} [options.addMetamodel] - When true, the Concerto metamodel is added to the model manager
      * @param {boolean} [options.enableMapType] - When true, the Concerto Map Type feature is enabled
+     * @param {boolean} [options.enableAliasedType] - When true, the Concerto Aliasing feature is enabled
      * @param {*} [processFile] - how to obtain a concerto AST from an input to the model manager
      */
     constructor(options, processFile) {
@@ -97,6 +98,7 @@
         // TODO Remove on release of MapType
         // Supports both env var and property based flag
         this.enableMapType = !!options?.enableMapType;
+        this.enableAliasedType = !!options?.enableAliasedType;
 
         // Cache a copy of the Metamodel ModelFile for use when validating the structure of ModelFiles later.
         this.metamodelModelFile = new ModelFile(this, MetaModelUtil.metaModelAst, undefined, MetaModelNamespace);
@@ -122,6 +124,14 @@
         return this.strict;
     }
 
+    /**
+     * Checks if the import aliasing feature is enabled.
+     * @returns {boolean} true if the enableAliasedType has been set
+     */
+    isAliasedTypeEnabled() {
+        return this.enableAliasedType;
+    }
+
     /**
      * Adds root types
      * @private
@@ -259,7 +269,7 @@
             if (this.isStrict()) {
                 throw new MetamodelException(err.message);
             } else {
                 console.warn('Invalid metamodel found. This will throw an exception in a future release. ', err.message);
             }
         }
 

packages/concerto-core/lib/introspect/modelfile.js

@@ -219,7 +219,6 @@
      */
     validate() {
         super.validate();
-
         // A dictionary of imports to versions to track unique namespaces
         const importsMap = new Map();
 
@@ -746,13 +745,40 @@
                 if (this.getModelManager().isStrict()){
                     throw new Error('Wilcard Imports are not permitted in strict mode.');
                 }
                 console.warn('DEPRECATED: Wilcard Imports are deprecated in this version of Concerto and will be removed in a future version.');
                 this.importWildcardNamespaces.push(imp.namespace);
                 break;
             case `${MetaModelNamespace}.ImportTypes`:
-                imp.types.forEach( type => {
-                    this.importShortNames.set(type, `${imp.namespace}.${type}`);
-                });
+                if (this.getModelManager().isAliasedTypeEnabled()) {
+                    const aliasedTypes = new Map();
+                    if (imp.aliasedTypes) {
+                        imp.aliasedTypes.forEach(({ name, aliasedName }) => {
+                            if(ModelUtil.isPrimitiveType(aliasedName)){
+                                throw new Error('Types cannot be aliased to primitive type');
+                            }
+                            aliasedTypes.set(name, aliasedName);
+                        });
+                    }
+                    // Local-name(aliased or non-aliased) is mapped to the Fully qualified type name
+                    imp.types.forEach((type) =>
+                        aliasedTypes.has(type)
+                            ? this.importShortNames.set(
+                                aliasedTypes.get(type),
+                                `${imp.namespace}.${type}`
+                            )
+                            : this.importShortNames.set(
+                                type,
+                                `${imp.namespace}.${type}`
+                            )
+                    );
+                } else {
+                    if (imp.aliasedTypes) {
+                        throw new Error('Aliasing disabled, set enableAliasType to true');
+                    }
+                    imp.types.forEach((type) => {
+                        this.importShortNames.set(type,`${imp.namespace}.${type}`);
+                    });
+                }
                 break;
             default:
                 this.importShortNames.set(imp.name, ModelUtil.importFullyQualifiedNames(imp)[0]);

packages/concerto-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@accordproject/concerto-core",
-  "version": "3.17.0",
+  "version": "3.17.1",
   "description": "Core Implementation for the Concerto Modeling Language",
   "homepage": "https://github.com/accordproject/concerto",
   "engines": {

packages/concerto-core/test/introspect/modelfile.js

@@ -608,6 +608,115 @@ describe('ModelFile', () => {
 
     });
 
+    describe('#aliasedImport', () => {
+
+        beforeEach(()=>{
+            modelManager.enableAliasedType=true;
+        });
+        it('should resolve aliased name of import type', () => {
+            const model = `
+            namespace org.acme
+            import org.saluja.{doc as d}`;
+
+            let modelFile = ParserUtil.newModelFile(modelManager, model);
+            modelFile.resolveImport('d').should.equal('org.saluja.doc');
+        });
+
+        it('should not throw if an aliased import exists for a type that exists in a valid namespace', () => {
+            const model1 = `
+            namespace org.saluja.ext
+            asset MyAsset2 identified by assetId {
+                o String assetId
+            }`;
+            const model2 = `
+            namespace org.acme
+            import org.saluja.ext.{MyAsset2 as m}
+            asset MyAsset identified by assetId {
+                o String assetId
+                o m[] arr
+            }`;
+            let modelFile1 = ParserUtil.newModelFile(modelManager, model1);
+            modelManager.addModelFile(modelFile1);
+            let modelFile2 = ParserUtil.newModelFile(modelManager, model2);
+            (() => modelFile2.validate()).should.not.throw();
+        });
+
+        it('should not throw if an duplicate types aliased to distinct aliased names', () => {
+            const model1 = `
+            namespace org.saluja
+            asset MyAsset identified by assetId {
+                o String assetId
+            }`;
+            const model2 = `
+            namespace org.acme
+            asset MyAsset identified by assetId {
+                o String assetId
+            }`;
+
+            const model3 = `
+            namespace org.acme2
+            import org.saluja.{MyAsset as m1}
+            import org.acme.{MyAsset as m2}
+
+            asset MyAsset identified by assetId {
+                o String assetId
+                o m1[] arr1
+                o m2[] arr2
+            }`;
+            let modelFile1 = ParserUtil.newModelFile(modelManager, model1);
+            modelManager.addModelFile(modelFile1);
+            let modelFile2 = ParserUtil.newModelFile(modelManager, model2);
+            modelManager.addModelFile(modelFile2);
+            let modelFile3 = ParserUtil.newModelFile(modelManager, model3);
+            (() => modelFile3.validate()).should.not.throw();
+        });
+
+        it('should not throw if map value is an aliased type', () => {
+            const model1 = `
+            namespace org.saluja
+            asset Student identified by rollno {
+                o String rollno
+            }`;
+            const model2 = `
+            namespace org.acme
+            import org.saluja.{Student as stud}
+
+            map StudMap{
+            o DateTime
+            o stud
+            }`;
+            modelManager.enableMapType=true;
+            let modelFile1 = ParserUtil.newModelFile(modelManager, model1);
+            modelManager.addModelFile(modelFile1);
+            let modelFile2 = ParserUtil.newModelFile(modelManager, model2);
+            (() => modelFile2.validate()).should.not.throw();
+        });
+
+        it('should not throw if declaration is extended on a aliased type declaration', () => {
+            const model1 = `
+            namespace org.saluja
+
+            scalar nickname extends String
+            asset Vehicle identified by serialno {
+                o String serialno
+            }`;
+            const model2 = `
+            namespace org.acme
+            import org.saluja.{Vehicle as V,nickname as nk}
+
+            asset Car extends V{
+                o String company 
+                o nk shortname
+            }`;
+            modelManager.enableMapType = true;
+            let modelFile1 = ParserUtil.newModelFile(modelManager, model1);
+            modelManager.addModelFile(modelFile1);
+            let modelFile2 = ParserUtil.newModelFile(modelManager, model2);
+            (() => modelFile2.validate()).should.not.throw();
+        });
+    });
+
+
     describe('#isDefined', () => {
 
         let modelManager;

packages/concerto-core/types/lib/basemodelmanager.d.ts

@@ -24,6 +24,7 @@ declare class BaseModelManager {
      * @param {boolean} [options.metamodelValidation] - When true, modelfiles will be validated
      * @param {boolean} [options.addMetamodel] - When true, the Concerto metamodel is added to the model manager
      * @param {boolean} [options.enableMapType] - When true, the Concerto Map Type feature is enabled
+     * @param {boolean} [options.enableAliasedType] - When true, the Concerto Aliasing feature is enabled
      * @param {*} [processFile] - how to obtain a concerto AST from an input to the model manager
      */
     constructor(options?: {
@@ -32,6 +33,7 @@ declare class BaseModelManager {
         metamodelValidation?: boolean;
         addMetamodel?: boolean;
         enableMapType?: boolean;
+        enableAliasedType?: boolean;
     }, processFile?: any);
     processFile: any;
     modelFiles: {};
@@ -45,8 +47,10 @@ declare class BaseModelManager {
         metamodelValidation?: boolean;
         addMetamodel?: boolean;
         enableMapType?: boolean;
+        enableAliasedType?: boolean;
     };
     enableMapType: boolean;
+    enableAliasedType: boolean;
     metamodelModelFile: any;
     /**
      * Returns true
@@ -58,6 +62,11 @@ declare class BaseModelManager {
      * @returns {boolean} true if the strict has been set
      */
     isStrict(): boolean;
+    /**
+     * Returns the value of the enableAliasedType option
+     * @returns {boolean} true if the enableAliasedType has been set
+     */
+    isAliasedTypeEnabled(): boolean;
     /**
      * Adds root types
      * @private