@sap/cds-compiler 6.2.2 → 6.3.0

package/lib/transform/odata/createForeignKeys.js

@@ -2,77 +2,78 @@
 
 const { isBuiltinType } = require('../../base/builtins');
 const { setProp } = require('../../base/model');
-const { applyTransformations, implicitAs, copyAnnotations, isDeepEqual } = require('../../model/csnUtils');
+const {
+  applyTransformations, implicitAs, copyAnnotations, isDeepEqual,
+} = require('../../model/csnUtils');
 const { EdmTypeFacetNames } = require('../../edm/EdmPrimitiveTypeDefinitions');
 const { adaptAnnotationsRefs } = require('./adaptAnnotationRefs');
 
 function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iterateOptions = {}) {
+  const { error } = messageFunctions;
+
+  applyTransformations(csn, { elements: createForeignKeysInCsn, params: createForeignKeysInCsn },
+                       [], iterateOptions);
+
+  /**
+   * Process a given elements or params dictionary and create foreign key elements.
+   *
+   * @param {object} parent The thing HAVING params or elements
+   * @param {string} prop
+   * @param {object} dict The params or elements thing
+   * @param {CSN.Path} path
+   */
+  function createForeignKeysInCsn( parent, prop, dict, path ) {
+    const orderedElements = [];
+    // First, generate the FK elements for given element
+    Object.entries(dict).forEach(([ elementName, element ]) => {
+      orderedElements.push([ elementName, element ]);
+      if (!csnUtils.isManagedAssociation(element))
+        return;
+      const elementPath = path.concat(prop, elementName);
+      const generatedForeignKeys = createForeignKeysForElement(elementPath, element, elementName, csn, options, '_');
+
+      // Second, finalize the generated FK elements
+      const refCount = generatedForeignKeys.reduce((acc, fk) => {
+        // count duplicates
+        if (acc[fk.prefix])
+          acc[fk.prefix]++;
+        else
+          acc[fk.prefix] = 1;
+
+        // check for name clash with existing elements
+        if (parent[prop][fk.prefix] && isDeepEqual(element, parent[prop][fk.prefix], true)) {
+          // error location is the colliding element
+          error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-exists', name: fk.prefix, art: elementName });
+        }
+        // attach a proper $path
+        setProp(element, '$path', elementPath);
+        return acc;
+      }, Object.create(null));
 
-    const { error } = messageFunctions;
-
-    applyTransformations(csn, { elements: createForeignKeysInCsn, params: createForeignKeysInCsn},
-                         [], iterateOptions);
-
-    /**
-     * Process a given elements or params dictionary and create foreign key elements.
-     *
-     * @param {object} parent The thing HAVING params or elements
-     * @param {string} prop
-     * @param {object} dict The params or elements thing
-     * @param {CSN.Path} path
-     */
-    function createForeignKeysInCsn( parent, prop, dict, path ) {
-      const orderedElements = [];
-      // First, generate the FK elements for given element
-      Object.entries(dict).forEach(([elementName, element]) => {
-        orderedElements.push([ elementName, element ]);
-        if (!csnUtils.isManagedAssociation(element)) return;
-        const elementPath = path.concat(prop, elementName);
-        const generatedForeignKeys = createForeignKeysForElement(elementPath, element, elementName, csn, options, '_');
-
-        // Second, finalize the generated FK elements
-        const refCount = generatedForeignKeys.reduce((acc, fk) => {
-          // count duplicates
-          if (acc[fk.prefix])
-            acc[fk.prefix]++;
-          else
-            acc[fk.prefix] = 1;
-
-          // check for name clash with existing elements
-          if (parent[prop][fk.prefix] && isDeepEqual(element, parent[prop][fk.prefix], true)) {
-            // error location is the colliding element
-            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-exists', name: fk.prefix, art: elementName });
-          }
-          // attach a proper $path
-          setProp(element, '$path', elementPath);
-          return acc;
-        }, Object.create(null));
-
-        // set default for single foreign key from association (if available)
-        if (element.default?.val !== undefined && generatedForeignKeys.length === 1)
+      // set default for single foreign key from association (if available)
+      if (element.default?.val !== undefined && generatedForeignKeys.length === 1)
         generatedForeignKeys[0].foreignKey.default = element.default;
 
-        // check for duplicate foreign keys
-        Object.entries(refCount).forEach(([ name, occ ]) => {
-          if (occ > 1)
-            error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-gen', name, art: elementName });
-        });
-        if (element.keys) {
-          if (options.transformation === 'effective')
-            delete element.default;
-        }
-
-        adaptAnnotationsRefs(generatedForeignKeys, csnUtils, messageFunctions);
-        setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => { 
-          return { name: gfk.prefix, origin: gfk.originalKey, source: gfk.sourceElement } } ));
-        orderedElements.push(...generatedForeignKeys.map(gfk => [ gfk.prefix, gfk.foreignKey ]));
+      // check for duplicate foreign keys
+      Object.entries(refCount).forEach(([ name, occ ]) => {
+        if (occ > 1)
+          error('name-duplicate-element', elementPath, { '#': 'flatten-fkey-gen', name, art: elementName });
       });
+      if (element.keys) {
+        if (options.transformation === 'effective')
+          delete element.default;
+      }
 
-      parent[prop] = orderedElements.reduce((elementsAccumulator, [ name, element ]) => {
-        elementsAccumulator[name] = element;
-        return elementsAccumulator;
-      }, Object.create(null));
-    }
+      adaptAnnotationsRefs(generatedForeignKeys, csnUtils, messageFunctions);
+      setProp(element, '$generatedForeignKeys', generatedForeignKeys.map(gfk => ({ name: gfk.prefix, origin: gfk.originalKey, source: gfk.sourceElement }) ));
+      orderedElements.push(...generatedForeignKeys.map(gfk => [ gfk.prefix, gfk.foreignKey ]));
+    });
+
+    parent[prop] = orderedElements.reduce((elementsAccumulator, [ name, element ]) => {
+      elementsAccumulator[name] = element;
+      return elementsAccumulator;
+    }, Object.create(null));
+  }
 
   function createForeignKeysForElement(path, element, prefix, csn, options, pathDelimiter, lvl = 0, originalKey = {} ) {
     const special$self = !csn?.definitions?.$self && '$self';
@@ -112,14 +113,14 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
         const continuePath = getContinuePath([ 'keys', keyIndex ]);
         const alias = key.as || implicitAs(key.ref);
         const result = csnUtils.inspectRef(continuePath);
-        let gfks = createForeignKeysForElement(result, result.art, alias, csn, options, pathDelimiter, lvl + 1,
-          lvl === 0 ? key : originalKey);
+        const gfks = createForeignKeysForElement(result, result.art, alias, csn, options, pathDelimiter, lvl + 1,
+                                                 lvl === 0 ? key : originalKey);
         if (lvl === 0) {
           gfks.forEach(gfk => gfk.keyAnnotations.push( ...copyAnnotations(key, gfk.foreignKey)));
-          Object.keys(key).forEach( prop => {
+          Object.keys(key).forEach( (prop) => {
             // once applied -> remove the annotations from the keys array, to keep the OData CSN size as small as possible
             if (prop[0] === '@')
-              delete key[prop]
+              delete key[prop];
           });
         }
         fks = fks.concat(gfks);
@@ -138,18 +139,20 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
     // we have reached a leaf element, create a foreign key
     else if ((finalElement.type == null || isBuiltinType(finalElement.type)) && !finalElement.on) {
       const newFk = Object.create(null);
-      [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`) ].forEach((prop) => {
+      [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${ f }`) ].forEach((prop) => {
         // copy props from original element to preserve derived types!
         if (element[prop] !== undefined)
           newFk[prop] = element[prop];
       });
-      let result = { prefix, foreignKey: newFk, originalKey, keyAnnotations: [], sourceElement: finalElement }
+      const result = {
+        prefix, foreignKey: newFk, originalKey, keyAnnotations: [], sourceElement: finalElement,
+      };
       return [ result ];
     }
 
     fks.forEach((fk) => {
       // prepend current prefix
-      fk.prefix = `${prefix}${pathDelimiter}${fk.prefix}`;
+      fk.prefix = `${ prefix }${ pathDelimiter }${ fk.prefix }`;
       // if this is the entry association, decorate the final foreign keys with the association props/annos
       if (lvl === 0) {
         fk.foreignKey['@odata.foreignKey4'] = prefix;
@@ -158,7 +161,7 @@ function createForeignKeyElements(csn, options, messageFunctions, csnUtils, iter
         fkPath.push(fk.prefix);
         setProp(fk.foreignKey, '$path', fkPath);
 
-        const allowedOverwriteAnnotationNames = ['@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`)];
+        const allowedOverwriteAnnotationNames = [ '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${ f }`) ];
         const validAnnoNames = Object.keys(element).filter(pn => pn[0] === '@' && !allowedOverwriteAnnotationNames.includes(pn));
         copyAnnotations(element, fk.foreignKey, false, {}, validAnnoNames);
         const overwriteAnnoNames = Object.keys(element).filter(pn => allowedOverwriteAnnotationNames.includes(pn));