fix(concerto-core): add opt-out for reserved system type name clashes (#1215)

* fix(concerto-core): add opt-out for reserved system type name clashes

Signed-off-by: muhammed-abdulkadir <muhammed.abdulkadir@docusign.com>

* fix(concerto-core): detect reserved system-type clashes via resolved import metadata

Signed-off-by: muhammed-abdulkadir <muhammed.abdulkadir@docusign.com>

* refactor(*): rename dangerouslyAllowReservedSystemTypeNames to dangerouslyAllowReservedSystemTypeNamesInUserModels

Signed-off-by: muhammed-abdulkadir <muhammed.abdulkadir@docusign.com>

---------

Signed-off-by: muhammed-abdulkadir <muhammed.abdulkadir@docusign.com>
Co-authored-by: muhammed-abdulkadir <muhammed.abdulkadir@docusign.com>

Author: muhabdulkadir

packages/concerto-core/src/basemodelmanager.ts

@@ -93,17 +93,18 @@ class BaseModelManager {
      options: any;
      decoratorValidation: any;
      metamodelModelFile: any;
-     /**
+    /**
      * Create the ModelManager.
      * @constructor
      * @param {object} [options] - ModelManager options, also passed to Serializer
      * @param {Object} [options.regExp] - An alternative regular expression engine.
      * @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.dangerouslyAllowReservedSystemTypeNamesInUserModels] - Transitional escape hatch; when true, declarations may use reserved system type names
      * @param {object} [options.decoratorValidation] - the decorator validation configuration
      * @param {string} [options.decoratorValidation.missingDecorator] - the validation log level for missingDecorator decorators: off, warning, error
      * @param {string} [options.decoratorValidation.invalidDecorator] - the validation log level for invalidDecorator decorators: off, warning, error
-    * @param {*} [processFile] - how to obtain a concerto AST from an input to the model manager
+     * @param {*} [processFile] - how to obtain a concerto AST from an input to the model manager
     */
     constructor(options?: ModelManagerOptions, processFile?: (fileName: string | null, modelInput: string | unknown) => ModelFileSource) {
         this.processFile = processFile ? processFile : defaultProcessFile;

packages/concerto-core/src/introspect/declaration.ts

@@ -80,13 +80,44 @@ class Declaration extends Decorated {
      */
     validate(...args) {
         super.validate(...args);
+        const modelFile = this.getModelFile();
 
         // #648 - check for clashes against imported types
-        if (this.getModelFile().isImportedType(this.getName())){
+        if (modelFile.isImportedType(this.getName())) {
+            const dangerouslyAllowReservedSystemTypeNamesInUserModels = Boolean(modelFile.getModelManager()?.options?.dangerouslyAllowReservedSystemTypeNamesInUserModels);
+            if (dangerouslyAllowReservedSystemTypeNamesInUserModels && this.isReservedSystemTypeImport(modelFile, this.getName())) {
+                return;
+            }
+
             throw new IllegalModelException(`Type '${this.getName()}' clashes with an imported type with the same name.`, this.modelFile, this.ast.location);
         }
     }
 
+    /**
+     * Determines whether a type name resolves to a reserved type in the Concerto
+     * system namespace.
+     * @param {ModelFile} modelFile - the current model file
+     * @param {string} typeName - local/imported type name
+     * @returns {boolean} true if the resolved import is a reserved system type
+     */
+    private isReservedSystemTypeImport(modelFile, typeName) {
+        const importedType = modelFile.getType(typeName);
+        if (!importedType || typeof importedType === 'string') {
+            return false;
+        }
+
+        const importedModelFile = importedType.getModelFile();
+        if (!importedModelFile || !importedModelFile.isSystemModelFile()) {
+            return false;
+        }
+
+        return importedType.isConcept()
+            || importedType.isAsset()
+            || importedType.isTransaction()
+            || importedType.isParticipant()
+            || importedType.isEvent();
+    }
+
     /**
      * Returns the ModelFile that defines this class.
      *

packages/concerto-core/src/modelmanager.ts

@@ -61,6 +61,7 @@ class ModelManager extends BaseModelManager {
      * @constructor
      * @param {object} [options] - ModelManager options, also passed to Serializer
      * @param {Object} [options.regExp] - An alternative regular expression engine.
+     * @param {boolean} [options.dangerouslyAllowReservedSystemTypeNamesInUserModels] - Transitional escape hatch; when true, declarations may use reserved system type names
      */
     constructor(options: ModelManagerOptions = {}) {
         super(options, ctoProcessFile(options));

packages/concerto-core/src/types.ts

@@ -18,6 +18,9 @@ export interface ModelManagerOptions {
     regExp?: RegExp;
     metamodelValidation?: boolean;
     addMetamodel?: boolean;
+    // Transitional migration escape hatch for legacy models.
+    // This option is temporary and will be removed in a future release.
+    dangerouslyAllowReservedSystemTypeNamesInUserModels?: boolean;
     decoratorValidation?: {
         missingDecorator?: string;
         invalidDecorator?: string;

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

@@ -367,6 +367,47 @@ describe('ModelFile', () => {
             }).should.throw('Type \'Transaction\' clashes with an imported type with the same name.');
         });
 
+        it('should allow a system type name when dangerouslyAllowReservedSystemTypeNamesInUserModels is enabled', () => {
+            const myModelManager = new ModelManager({
+                dangerouslyAllowReservedSystemTypeNamesInUserModels: true,
+            });
+
+            const model = `
+            namespace A@1.0.0
+            asset Asset identified by assetId {
+                o String assetId
+            }
+            `;
+
+            const modelFile = ParserUtil.newModelFile(myModelManager, model);
+            myModelManager.addModelFile(modelFile);
+            myModelManager.getType('A@1.0.0.Asset').getName().should.equal('Asset');
+        });
+
+        it('should still fail non-system clashes when dangerouslyAllowReservedSystemTypeNamesInUserModels is enabled', () => {
+            const myModelManager = new ModelManager({
+                dangerouslyAllowReservedSystemTypeNamesInUserModels: true,
+            });
+
+            const imported = `namespace A@1.0.0
+            concept B {
+                o String name
+            }`;
+
+            const clashing = `namespace B@1.0.0
+            import A@1.0.0.{B}
+            concept B {
+            }`;
+
+            const importedModelFile = ParserUtil.newModelFile(myModelManager, imported);
+            myModelManager.addModelFile(importedModelFile);
+
+            const clashingModelFile = ParserUtil.newModelFile(myModelManager, clashing);
+            (() => {
+                myModelManager.addModelFile(clashingModelFile);
+            }).should.throw('Type \'B\' clashes with an imported type with the same name.');
+        });
+
     });
 
     describe('#getDefinitions', () => {