@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/transform/odata/toFinalBaseType.js

@@ -2,7 +2,7 @@
 
 const {
   forEachDefinition, forEachMemberRecursively,
-  isBuiltinType, cloneCsnDictionary,
+  isBuiltinType, cloneCsnDictionary, cloneCsnNonDict,
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
@@ -86,21 +86,95 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     // EDMX at the moment and the reference in the OData CSN is fulfilled.
     if (node.kind === 'event') return;
 
-    if (isExpandable(node, defName) || node.kind === 'type') {
-      transformers.toFinalBaseType(node);
-      if (node.type && !isBuiltinType(node.type)) {
-        // handle array of defined via a named type
-        // example in actions: 'action act() return Primitive; type Primitive: array of String;'
-        const currService = csnUtils.getServiceName(defName);
-        const finalType = csnUtils.getFinalTypeDef(node.type);
-        if (finalType.items && isBuiltinType(finalType.items.type)) {
-          if (!isArtifactInService(node.type, currService) || !isV4) {
-            node.items = finalType.items;
+    // elements have precedence over type
+    if (node.type && (!isBuiltinType(node.type) &&isExpandable(node, defName) || node.kind === 'type')) {
+      // 1. Get the final type of the node (resolve derived type chain)
+      const finalType = csnUtils.getFinalBaseType(node.type);
+      if (finalType) {
+        // The type replacement depends on whether 'node' is a definition or a member[element].
+        if (node.kind) {
+          // It is a definition and we expand to builtin type and to elements
+          // type T: S; --> Integer;
+          // type S: X; --> Integer;
+          // type X: Integer;
+          //
+          // type A: B; -> {...}
+          // type B: C; -> { ... }
+          // type C { .... };
+          if (isBuiltinType(finalType)) {
+            // use transformUrilsNew::toFinalBaseType for the moment,
+            // as it is collects along the chain of types
+            // attributes that need to be propagated
+            // enum, length, scale, etc.
+            transformers.toFinalBaseType(node);
+            // node.type = finalType;
+          }
+          else if (csnUtils.isStructured(finalType)) {
+            cloneElements(finalType);
+          }
+          else if (node.type && node.items)
             delete node.type;
+        }
+        else {
+          // this is a member and we expand to final base only if builtin
+          //  type T: S; --> Integer;
+          //  type S: X; --> Integer;
+          //  type X: Integer;
+          //
+          //  type {
+          //    struct_elt: many A; ---> stays the same
+          //    scalar_elt: T; ---> Integer;
+          //    type_ref_elt: type of struct_elt;
+          //  };
+          //  type A: B; -> {...}
+          //  type B: C; -> { ... }
+          //  type C { .... };
+          if (isBuiltinType(finalType)) {
+            // use transformUrilsNew::toFinalBaseType for the moment,
+            // as it is collects along the chain of types
+            // attributes that need to be propagated
+            // enum, length, scale, etc.
+            transformers.toFinalBaseType(node);
+            // node.type = finalType;
+          }
+          else if (node.type && node.type.ref) {
+            cloneElements(finalType);
           }
         }
       }
     }
+    if (node.type && !isBuiltinType(node.type)) {
+        // handle array of defined via a named type
+        // example in actions: 'action act() return Primitive; type Primitive: array of String;'
+      const currService = csnUtils.getServiceName(defName);
+      const finalType = csnUtils.getFinalTypeDef(node.type);
+      if (finalType.items && isBuiltinType(finalType.items.type)) {
+        if (!isArtifactInService(node.type, currService) || !isV4) {
+          node.items = finalType.items;
+          delete node.type;
+        }
+      }
+    }
+
+    function cloneElements(finalType) {
+      // cloneCsn only works correctly if we start "from the top"
+      let clone;
+      // do the clone only if really needed
+      if((finalType.items && !node.items) ||
+         (finalType.elements && !node.elements))
+        clone = cloneCsnNonDict({ definitions: { 'TypeDef': finalType } }, options);
+      if (finalType.items) {
+        delete node.type;
+        if(!node.items)
+          Object.assign(node, { items: clone.definitions.TypeDef.items });
+      }
+      if (finalType.elements) {
+        if(!finalType.items)
+          delete node.type;
+        if(!node.elements)
+          Object.assign(node, { elements: clone.definitions.TypeDef.elements });
+      }
+    }
   }
 
   function isExpandable(node, defName) {

package/lib/transform/odata/typesExposure.js

@@ -8,35 +8,29 @@
 
 const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { cloneCsn, isBuiltinType, forEachDefinition, forEachMember, cloneCsnDictionary } = require('../../model/csnUtils');
+const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember } = require('../../model/csnUtils');
 const { copyAnnotations } = require('../../model/csnUtils');
 
-/**
- * @param {CSN.Model} csn
- * @param {function} whatsMyServiceName
- * @param {CSN.Options} options
- * @param {*} csnUtils
- * @param {object} message message object with { error } function
- */
-function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
+function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackSchemaName, options, csnUtils, message) {
   const { error } = message;
   // are we working with OData proxies or cross-service refs
   const isMultiSchema = options.toOdata.version === 'v4' && (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs);
   // collect in this variable all the newly exposed types
-  const exposedStructTypes = [];
   const schemas = Object.create(null);
+  const exposedTypes = Object.create(null);
   // walk through the definitions of the given CSN and expose types where needed
   forEachDefinition(csn, (def, defName, propertyName, path) => {
     // we do expose types only for definition from inside services
     const serviceName = whatsMyServiceName(defName, false);
-    if (serviceName) {
-      if (['type', 'entity', 'view'].includes(def.kind)) {
+    // run type exposure only on requested services if not in multi schema mode
+    // multi schema mode requires a proper type exposure for all services as a prerequisite
+    // for the proxy exposure
+    if (serviceName && requestedServiceNames.includes(serviceName)) {
+      if (def.kind === 'type' || def.kind === 'entity') {
         forEachMember(def, (element, elementName, propertyName, path) => {
-          if (['elements', 'params'].includes(propertyName)) {
-            const artificialtName = `${isMultiSchema ?
-              defNameWithoutServiceOrContextName(defName, serviceName)
-              : defNameWithoutServiceOrContextName(defName, serviceName).replace(/\./g, '_')}_${elementName}`;
-            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, artificialtName, path);
+          if (propertyName === 'elements' || propertyName === 'params') {
+            const newTypeName = getNewTypeName(element, elementName, defName, serviceName);
+            exposeTypeOf(element, element.key || propertyName === 'params', elementName, defName, serviceName, newTypeName, path);
           }
         }, path);
       }
@@ -55,46 +49,26 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
   });
 
   return schemas;
-  /**
-   * General function used for exposing  a type of given element
-   * @param {object} node
-   * @param {string} memberName
-   * @param {string} service
-   * @param {string} artificialName
-   * @param {CSN.Path} path
-   */
-  function exposeTypeOf(node, isKey, memberName, defName, service, artificialName, path) {
-    if (isArrayed(node))
-      exposeArrayOfTypeOf(node, isKey, memberName, defName, service, artificialName, path);
-    else if (csnUtils.isStructured(node))
-      exposeStructTypeOf(node, isKey, memberName, defName, service, artificialName, path);
-  }
-
-  /**
-   * Check if a node is arrayed
-   * @param {object} node
-   */
-  function isArrayed(node) {
-    return node.items || (node.type && csnUtils.getFinalTypeDef(node.type).items);
-  }
 
-  /**
+/**
    * If an 'action' uses structured types as parameters or return values that are not exposed in 'service'
    * (because the types are anonymous or have a definition outside of 'service'),
    * create equivalent types in 'service' and make 'action' use them instead,
    * @param {Object} action
    * @param {String} actionName
-   * @param {String} service
+   * @param {String} serviceName
    */
-  function exposeTypesOfAction(action, actionName, defName, service, path) {
+  function exposeTypesOfAction(action, actionName, defName, serviceName, path) {
     if (action.returns) {
       const artificialName = `return_${actionName.replace(/\./g, '_')}`;
-      exposeTypeOf(action.returns, false, actionName, defName, service, artificialName, path.concat(['returns']));
+      const newTypeName = getNewTypeName(action.returns, undefined, artificialName, serviceName);
+      exposeTypeOf(action.returns, false, actionName, defName, serviceName, newTypeName, path.concat(['returns']));
     }
 
     action.params && Object.entries(action.params).forEach(([paramName, param]) => {
-      const artificialName = `param_${actionName.replace(/\./g, '_')}_${paramName}`;
-      exposeTypeOf(param, false, actionName, defName, service, artificialName, path.concat(['params', paramName]));
+      const artificialName = `param_${actionName.replace(/\./g, '_')}`;//_${paramName}`;
+      const newTypeName = getNewTypeName(param, paramName, artificialName, serviceName);
+      exposeTypeOf(param, false, actionName, defName, serviceName, newTypeName, path.concat(['params', paramName]));
     });
   }
 
@@ -104,93 +78,139 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
    * for a value of the 'node.type' property.
    * @param {Object} node
    * @param {String} memberName
-   * @param {String} service
-   * @param {String} artificialName
+   * @param {String} serviceName
+   * @param {String} newTypeName
    */
-  function exposeStructTypeOf(node, isKey, memberName, defName, service, artificialName, path, parentName) {
-    if (node.items) exposeStructTypeOf(node.items, isKey, memberName, defName, service, artificialName, path);
-
-    // start conservative, assume we're in a named type
-    let isAnonymous = false;
-
-    if (isExposableStructure(node)) {
-      let typeDef = node.type ? csnUtils.getCsnDef(node.type) : /* structure|anonymous type */ node;
-      let newTypeId = node.type ? `${isMultiSchema ? node.type : node.type.replace(/\./g, '_')}` : artificialName;
-      let newTypeFullName =
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName) {
+    const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable(node);
+    if (isExposable) {
+      // this is the name used to register the new type in csn.definitions
+      let fullQualifiedNewTypeName =
         isMultiSchema
-          ? node.type ? getTypeNameInMultiSchema(node.type, service) : getAnonymousTypeNameInMultiSchema(artificialName, parentName || defName)
-          : `${service}.${newTypeId}`;
+          ? (node.type || (node.items && node.items.type)
+              ? getTypeNameInMultiSchema(node.type|| (node.items && node.items.type), serviceName)
+              : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
+          : `${serviceName}.${newTypeName}`;
 
-      // With the redirection of sub elements, the element which is of named type with an association is now expanded and contains the association
-      // and the new target. Consequently, we now have both type and elements properties in this case, and the elements should be taken as a priority
-      // as the correct target is there and no longer in the type definition
-      let newTypeElements = (node.type && node.elements) ? node.elements : typeDef.elements;
-      // if node and typeDef are identical, we're anonymous
-      isAnonymous = node === typeDef;
-      // if we've left the anonymous world, we're no longer in a key def
-      if (!isAnonymous)
+      // as soon as we leave of the anonymous world,
+      // we're no longer in a key def => don't set notNull:true on named types
+      if (!isAnonymous && isKey)
         isKey = false;
 
-      let newType = exposeStructType(newTypeFullName, newTypeElements, memberName, path);
-      if (!newType) {
-        // Error already reported
-        return;
+      // check if that type is already defined
+      let newType = csn.definitions[fullQualifiedNewTypeName];
+      if (newType) {
+        // error, if it was not exposed by us
+        if (!exposedTypes[fullQualifiedNewTypeName]) {
+          error(null, path, `Cannot create artificial type "${fullQualifiedNewTypeName}" for "${memberName}" because the name is already used`);
+          return;
+        }
       }
+      else {
+        /* Expose new structured type
+         * Treat items.elements as ordinary elements for now.
+         */
+        newType = createNewStructType(elements);
+        if (node.$location)
+          setProp(newType, '$location', node.$location);
 
-      if (node.$location) setProp(newType, '$location', node.$location);
-      setProp(newType, '$exposedBy', 'typeExposure');
+        csn.definitions[fullQualifiedNewTypeName] = newType;
+        exposedTypes[fullQualifiedNewTypeName] = 1;
 
-      // Recurse into elements of 'type' (if any) and expose them as well (is needed)
-      newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
-        if (node.elements && node.elements[elemName].$location) setProp(newElem, '$location', node.elements[elemName].$location);
-        exposeStructTypeOf(newElem,
-          isKey,
-          memberName,
-          typeDef.kind === 'type' ? node.type : defName,
-          service,
-          isMultiSchema ? `${newTypeFullName}_${elemName}` : `${newTypeId}_${elemName}`,
-          path,
-          newTypeFullName);
-      });
-      typeDef.kind === 'type' ? copyAnnotations(typeDef, newType) : copyAnnotations(node, newType);
-      delete node.elements;
-      node.type = newTypeFullName;
+        // Recurse into elements of 'type' (if any) and expose them as well (is needed)
+        newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
+          if (node.elements && node.elements[elemName].$location)
+            setProp(newElem, '$location', node.elements[elemName].$location);
+          defName = typeDef.kind === 'type' ? typeName : defName;
+          exposeTypeOf(newElem, isKey, elemName, defName, serviceName, 
+                       getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName);
+        });
+        copyAnnotations(typeDef, newType);
+        // if the origin type had items, add items to exposed type
+        if(typeDef.kind === 'type') {
+          if(typeDef.items) {
+            newType.items = { elements: newType.elements };
+            delete newType.elements;
+          }
+        }
+      }
+      // adjust current node to new type
+      if(node.items) {
+        delete node.items.elements;
+        delete node.type;
+        node.items.type = fullQualifiedNewTypeName;
+      }
+      else {
+        delete node.elements;
+        node.type = fullQualifiedNewTypeName;
+      }
     }
 
-    /**
-     * Returns whether the 'node' is for exposing the in service.
-     * There are 2 cases when we would like to expose a type is the service:
-     *  1. If the node is of user-defined type which is not part of the service
-     *  2. When we have structured element (the object has property 'elements')
-     * @param {Object} node
+     /**
+     * Check if the node's type can be exposed:
+     * 1) If it's an anonymous structured type (items.elements || elements)
+     * 2) If it's a named type resolve to the final type definition and
+     *    check if this is a structured type
+     * Returns an object that indicates 
+     *  - wether or not the type needs exposure
+     *  - the elements dictionary that needs to be cloned
+     *  - the typeDef, either the resolved type def or the node itself
+     *  - if structured type was anonymously defined
+     * @param {object} node
+     * @returns {object} { isExposable, typeDef, typeName, elements, isAnonymous }
      */
-    function isExposableStructure(node) {
-      let finalNodeType = node.type ? csnUtils.getFinalType(node.type) : undefined;
-      return finalNodeType && isArtifactInService(finalNodeType, service)
-        ? false
-        : csnUtils.isStructured(node);
+    function isTypeExposable(node) {
+      let typeName = undefined;
+      let typeDef = node;
+      let elements = (node.items && node.items.elements || node.elements)
+      // anonymous structured type
+      if(elements)
+        return { isExposable: true, typeDef, typeName, elements, isAnonymous: true };
+      // named type, resolve the type to inspect it
+      let type = node.items && node.items.type || node.type;
+      if(type) {
+        typeName = (type.ref && csnUtils.getFinalType(type)) || type;
+        typeDef = csnUtils.getFinalTypeDef(typeName);
+        const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
+        if(!isBuiltinType(typeName) && !isArtifactInService(typeName, serviceName)) {
+          while(!isBuiltinType(typeName)) {
+            typeDef = csnUtils.getFinalTypeDef(typeName);
+            if(typeDef) {
+              if((rc.elements = (typeDef.items && typeDef.items.elements || typeDef.elements)) !== undefined)
+                return rc;
+              type = typeDef.items && typeDef.items.type || typeDef.type;
+              typeName = (type.ref && csnUtils.getFinalType(type)) || type;
+            }
+            else {
+              throw Error(`Please debug me: ${typeName} not found`);
+            }
+          }
+        }
+      }
+      return { isExposable: false };
     }
 
+
     /**
      * Calculate the new type name that will be exposed in multi schema,
      * in case that the element has a named type.
      *
      * @param {string} typeName type of the element
-     * @param {string} service current service name
+     * @param {string} serviceName current service name
      */
-    function getTypeNameInMultiSchema(typeName, service) {
+    function getTypeNameInMultiSchema(typeName, serviceName) {
       const typeService = whatsMyServiceName(typeName);
       if (typeService) {
         // new type name without any prefixes
         const typePlainName = defNameWithoutServiceOrContextName(typeName, typeService);
-        const newSchemaName = `${service}.${typeService}`;
+        const newSchemaName = `${serviceName}.${typeService}`;
         createSchema(newSchemaName);
         // return the new type name
         return `${newSchemaName}.${typePlainName.replace(/\./g, '_')}`;
       } else {
         const typeContext = csnUtils.getContextOfArtifact(typeName);
         const typeNamespace = csnUtils.getNamespaceOfArtifact(typeName);
-        const newSchemaName = `${service}.${typeContext || typeNamespace || 'root'}`;
+        const newSchemaName = `${serviceName}.${typeContext || typeNamespace || fallBackSchemaName}`;
         // new type name without any prefixes
         const typePlainName = typeContext ? defNameWithoutServiceOrContextName(typeName, typeContext)
           : typeName.replace(`${typeNamespace}.`, '');
@@ -209,7 +229,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
      */
     function getAnonymousTypeNameInMultiSchema(typeName, parentName) {
       let currPrefix = parentName.substring(0, parentName.lastIndexOf('.'));
-      const newSchemaName = currPrefix || 'root';
+      const newSchemaName = currPrefix || fallBackSchemaName;
       // new type name without any prefixes
       const typePlainName = defNameWithoutServiceOrContextName(typeName, newSchemaName);
 
@@ -222,121 +242,49 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
      * @param {string} name
      */
     function createSchema(name) {
-      schemas[`${name}`] = { kind: 'schema', name };
+      schemas[name] = { kind: 'schema', name };
     }
 
     /**
-     * Expose a new type definition in the 'definitions' of the CSN and return that type(reusing such a type
-     * if it already exists).
-     * The new type has name 'typeName', elements which are 'elements'.
-     * 'parentName' is used for error reporting.x
-     * @param {String} typeName
+     * create a new structured type for 'elements'
      * @param {Object} elements
-     * @param {String} parentName
      */
-    function exposeStructType(typeName, elements, parentName, path) {
-      // If type already exists, reuse it (complain if not created here)
-      let type = csn.definitions[typeName];
-      if (type) {
-        if (!exposedStructTypes.includes(typeName)) {
-          error(null, path, `Cannot create artificial type "${typeName}" for "${parentName}" because the name is already used`);
-          return null;
-        }
-        return type;
-      }
-
+    function createNewStructType(elements) {
       // Create a type with empty elements
-      type = {
+      const type = {
         kind: 'type',
         elements: Object.create(null),
       };
+      setProp(type, '$exposedBy', 'typeExposure');
 
-      // Duplicate the type's elements
+      // Duplicate elements
       Object.entries(elements).forEach(([elemName, element]) => {
-        if (type.elements[elemName]) {
-          const path = ['definitions', typeName, 'elements', elemName];
-          error(null, path, `"${elemName}": Element name conflicts with existing element`);
-        }
-        let cloned = cloneCsn(element, options);
+        let cloned = cloneCsnNonDict(element, options);
         // if this was an anonymous sub element of a key, mark it as not nullable
         if(isAnonymous && isKey && !cloned.key && cloned.notNull === undefined)
           cloned.notNull = true;
         type.elements[elemName] = cloned;
       });
-
-      // add to the CSN
-      csn.definitions[typeName] = type;
-      // store typeName in set of exposed struct types
-      exposedStructTypes.push(typeName);
       return type;
     }
   }
 
-
-  // If a member is of type "array of <named type|anonymous type>", we expose the arrayed type,
-  // like we expose structures in structured mode
-  function exposeArrayOfTypeOf(node, isKey, memberName, defName, service, artificialName, path) {
-    // if anonymously defined in place -> we always expose the type
-    // this would be definition like 'elem: array of { ... }'
-    // and we use the artificial name for the new type name
-    if (node.items && !node.type) {
-      exposeStructTypeOf(node.items, isKey, memberName, defName, service, artificialName, path.concat('items'));
-    }
-    // we can have both of the 'type' and 'items' in the cases:
-    // 1. 'elem: Foo' and 'type Foo: array of Baz' and 'type Baz: { ... }'
-    // or 2. 'elem: Foo' and type Foo: array of Integer|String|...'
-    else if (node.type) {
-      let finalType = csnUtils.getFinalTypeDef(node.type);
-      if (finalType.items) {
-        if (!isArtifactInService(node.type, service)) {
-          let typeId = `${service}.${node.type.replace(/\./g, '_')}`;
-          let newType = exposeArrayedType(node.items || finalType.items, typeId);
-          // When we have in the model something like:
-          // type Foo: array of Bar; type Bar: { qux: Integer };
-          // In the type Foo we expand the first level of elements of the items like we have in CDL this:
-          // type Foo: array of { qux: Integer };
-          expandFirstLevelOfArrayed(newType);
-          node.type = typeId;
-        }
-        // case 1. - as we keep the type property, the items property is removed
-        if (node.items) delete node.items;
-      }
-    }
-
-    function exposeArrayedType(items, typeId) {
-      let newType = csn.definitions[typeId];
-      if (newType) {
-        if (!exposedStructTypes.includes(typeId)) {
-          error(null, newType.$path, `Cannot create artificial type "${typeId}" because the name is already used`);
-        }
-        return newType;
-      }
-      // create empty type
-      newType = {
-        kind: 'type',
-        items: Object.create(null),
-      }
-
-      // copy over the items
-      newType.items = cloneCsn(items, options);
-      csn.definitions[typeId] = newType;
-      exposedStructTypes.push(typeId);
-      return newType;
-    }
-  }
-
-  // In case we have in the model something like:
-  // type Foo: array of Bar; type Bar: { qux: Integer };
-  // In the type Foo we expand the first level of elements of the items like we have in CDL this:
-  // type Foo: array of { qux: Integer };
-  function expandFirstLevelOfArrayed(def) {
-    if (def.items.type && !isBuiltinType(def.items.type)) {
-      let finalType = csnUtils.getFinalTypeDef(def.items.type);
-      if (csnUtils.isStructured(finalType)) {
-        if (!def.items.elements) def.items.elements = cloneCsnDictionary(finalType.elements, options);
-        delete def.items.type;
-      }
-    }
+  /*
+   * Calculate the name of the exposed type based on the information, the element can provide
+   * If the element is typed, use the type name
+   * else assume it's a de-anonymized type, concatenate the element name to the defName
+  */
+  function getNewTypeName(element, elementName, typeNamePrefix, serviceName) {
+    // for the new type name node.type has precedence over node.items.type
+    const typeName = (!element.elements && element.type || element.items && !element.items.elements && element.items.type);
+    return typeName
+        ? `${isMultiSchema
+              ? typeName.split('.').pop() // use leaf element
+              : typeName.replace(/\./g, '_')}` // concatenate path
+        : ( elementName // returns has no elementName, return the precalculated prefix
+            ? `${defNameWithoutServiceOrContextName(typeNamePrefix, serviceName).replace(/\./g, '_')}_${elementName}`
+            : typeNamePrefix
+          );
   }
 }
 

package/lib/transform/odata/utils.js

@@ -18,7 +18,7 @@ function isAssociationOrComposition(artifact) {
   return isAssociation(artifact) || isComposition(artifact);
 }
 
-function isManagedAssociationElement(artifact) {
+function isManagedAssociation(artifact) {
   return artifact.target !== undefined && artifact.on === undefined;
 }
 
@@ -94,5 +94,5 @@ module.exports = {
   isArtifactInSomeService,
   isAssociationOrComposition,
   isLocalizedArtifactInService,
-  isManagedAssociationElement,
+  isManagedAssociation,
 }