@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/transform/odata/expandStructKeysInAssociations.js

@@ -1,59 +0,0 @@
-'use strict';
-
-const { forEachManagedAssociation } = require('./utils');
-const { attachPath, attachPathOnPartialCSN } = require('./attachPath');
-
-/**
- * This module runs through the model and for each managed association in it,
- * in case the foreign keys are structured, it is expanding them. Example:
- * entity A {
- *  toB: association to B { stru };
- * } // -> CSN: keys:[ { ref:['stru'] } ]
- *
- * entity B {
- *  stru: {
- *    subid: Integer;
- *  }
- * }
- * after expand -> keys:[ { ref: ['stru_subid'] } ]
- */
-module.exports = function (csn, referenceFlattener, csnUtils, isExternalServiceMember) {
-
-  forEachManagedAssociation(csn, (element) => {
-    if (element.keys) {
-      expandStructuredKeysForAssociation(element, referenceFlattener);
-    }
-  }, isExternalServiceMember);
-
-  // update paths and resolve references
-  attachPath(csn);
-  referenceFlattener.resolveAllReferences(csn, csnUtils.inspectRef, csnUtils.isStructured);
-
-  function expandStructuredKeysForAssociation(assoc, referenceFlattener) {
-    let newKeys = [];
-    for (let key of assoc.keys) {
-      // when are assigned $paths and when not???
-      let paths = key.$paths;
-      if (paths) {
-        let lastPath = paths[paths.length - 1];
-        let generatedElements = referenceFlattener.getGeneratedElementsForPath(lastPath);
-        if (generatedElements) {
-          generatedElements.forEach(elementName => {
-            let newRef = { ref: [elementName] };
-            if (key.as) {
-              newRef.as = elementName.replace(key.ref[0], key.as);
-            }
-            newKeys.push(newRef);
-          })
-          continue;
-        }
-      }
-      newKeys.push(key);
-    }
-
-    if (newKeys.length) {
-      attachPathOnPartialCSN(newKeys, assoc.$path.concat('keys'));
-      assoc.keys = newKeys;
-    }
-  }
-}

package/lib/transform/odata/generateForeignKeyElements.js

@@ -1,261 +0,0 @@
-'use strict';
-
-/**
- * The module handles the processing of foreign key for managed associations.
- */
-
-const { copyAnnotations } = require('../../model/csnUtils');
-const sortByAssociationDependency = require('./sortByAssociationDependency');
-const { flattenStructure } = require('./structureFlattener');
-const { setProp } = require('../../base/model');
-const { implicitAs } = require('../../model/csnRefs');
-
-/**
- *
- * @param {CSN.Model} csn
- * @param {*} options
- * @param {*} referenceFlattener
- * @param {*} csnUtils
- * @param {object} error;
- */
-module.exports = function (csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember) {
-
-  const structuredOData = options.toOdata.odataFormat === 'structured' && options.toOdata.version === 'v4';
-  const flatKeys = !structuredOData || (structuredOData && options.toOdata.odataForeignKeys);
-
-  // sort all associations by their dependencies
-  const sortedAssociations = sortByAssociationDependency(csn, referenceFlattener, isExternalServiceMember);
-
-  // generate foreign keys
-  processSortedAssociations(sortedAssociations, flatKeys);
-
-
-  function processSortedAssociations(sortedAssociations, flatKeys,) {
-    // The map will collect all generated foreign key names for the specific path
-    let generatedForeignKeyNamesForPath = Object.create(null); // map<path,[key-name]>
-
-    sortedAssociations.forEach(item => {
-      const { definitionName, structuralNodeName, elementName, element, parent, path } = item;
-
-      if (csnUtils.isManagedAssociation(element) && element.keys) {
-        if (flatKeys) // tackling the ref value in assoc.keys
-          takeoverForeignKeysOfTargetAssociations(element, path, generatedForeignKeyNamesForPath);
-        // TODO: move in separate function
-        fixCardinality(element);
-      }
-
-      let arrayOfGeneratedForeignKeyNames = generateForeignKeys(definitionName, structuralNodeName, elementName, element, parent, path);
-      generatedForeignKeyNamesForPath[item.path.join('/')] = arrayOfGeneratedForeignKeyNames;
-    })
-
-  }
-
-  /**
-   * if a key is an association and it poins to another association,
-   * the foreign keys of the target association become primary keys
-   * in the current association
-   */
-  function takeoverForeignKeysOfTargetAssociations(assoc, path, generatedForeignKeyNamesForPath) {
-    let newResult = [];
-    assoc.keys.forEach( (key, keyIndex) => {
-      let keyPath = path.concat('keys', keyIndex);
-      let resolved = csnUtils.inspectRef(keyPath)
-      let targetElement = resolved.art;
-      if (targetElement) {
-        if (csnUtils.isAssociation(targetElement.type)) {
-          // association key
-          expandAssociationKey(key);
-        } else {
-          newResult.push(key);
-        }
-      } else {
-        // target element does not exist, warning is already reported, pass the key anyway
-        newResult.push(key);
-      }
-    });
-
-    function expandAssociationKey(key) {
-      let paths = key.$paths;
-      if (!paths) return;
-      let lastPath = paths[paths.length - 1];
-      let transitionPath = referenceFlattener.getElementTransition(lastPath)
-      if (transitionPath)
-        lastPath = transitionPath;
-      let generatedKeys = generatedForeignKeyNamesForPath[lastPath.join('/')];
-      if (!generatedKeys) return;
-      generatedKeys.forEach(fkName => {
-        let newFkRef = { ref: [fkName] };
-        if (key.as) {
-          let alias = fkName.replace(key.ref[0], key.as);
-          setProp(newFkRef, 'as', alias);
-        }
-        newResult.push(newFkRef);
-      })
-    } // expandAssociationKey
-
-    assoc.keys = newResult;
-
-  }
-
-  function fixCardinality(assoc) {
-    if (assoc.notNull) {
-      if (!assoc.cardinality) {
-        assoc.cardinality = {};
-      }
-      if (assoc.cardinality.min === undefined) {
-        assoc.cardinality.min = 1;
-      }
-    }
-  }
-
-  /**
-   * Generates foreign keys and returns their names as an array
-   */
-  function generateForeignKeys(definitionName, structuralNodeName, assocName, assoc, parent, path) {
-    let foreignKeyElements = Object.create(null);
-
-    // First, loop over the keys array of the association and generate the FKs.
-    // The result of all the FKs for the given association is accumulated
-    // in the 'foreignKeyElements' dictionary
-    assoc.keys.forEach( (key, keyIndex) => {
-      let keyPath = path.concat('keys', keyIndex);
-
-      let foreignKeyElementsForKey = generateForeignKeysForRef(assoc, assocName, key, keyPath);
-      Object.assign(foreignKeyElements, foreignKeyElementsForKey);
-    });
-
-    // After that, add the new elements to the definition.
-    // At the same time:
-    //    -> Check for coliding element's name
-    //      &
-    //    -> Propagate annotations from the association
-    if (parent.items) // proceed to items of such
-      parent = parent.items;
-    if (parent.returns)
-      parent = parent.returns.items || parent.returns;
-
-    const dictionary = parent[structuralNodeName];
-    let currElementsNames = Object.keys(parent[structuralNodeName]);
-    for (const [foreignKeyName, foreignKey] of Object.entries(foreignKeyElements)) {
-      copyAnnotations(assoc, foreignKey, true);
-      // Insert artificial element into artifact, with all cross-links
-      if (dictionary[foreignKeyName]) {
-        if (!(dictionary[foreignKeyName]['@odata.foreignKey4'] || isDeepEqual(dictionary[foreignKeyName], foreignKey))) {
-          const path = dictionary[foreignKeyName].$path;
-          error(null, path, { name: foreignKeyName, art: assocName }, 'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
-        }
-      }
-    }
-
-    // make sure the generated foreign key(s) is added right after the association (that it belongs to) in the elements dictionary
-    const assocIndex = currElementsNames.findIndex(elemName => elemName === assocName);
-    // if (flatKeys)
-    currElementsNames.splice(assocIndex + 1, 0, ...Object.keys(foreignKeyElements));
-
-    parent[structuralNodeName] = currElementsNames.reduce((previous, name) => {
-      previous[name] = dictionary[name] || foreignKeyElements[name];
-      return previous;
-    }, Object.create(null));
-
-    return Object.keys(foreignKeyElements);
-  }
-
-  // FIXME: Very similar code to
-  // transformUtilsNew::getForeignKeyArtifact & createForeignKeyElement
-  // Can this be streamlined?
-  function generateForeignKeysForRef(assoc, assocName, foreignKeyRef, pathInKeysArr, foreignKey4 = assocName) {
-    // in structured OData, might be more than one generated FKs
-    let generatedFks = Object.create(null);
-    const fkArtifact = csnUtils.inspectRef(pathInKeysArr).art;
-    if(fkArtifact) {
-      if (csnUtils.isStructured(fkArtifact)) {
-        processStucturedKey(fkArtifact, assocName, foreignKeyRef);
-      } else {
-      // built-in
-        const foreignKeyElementName = `${assocName.replace(/\./g, '_')}_${foreignKeyRef.as || foreignKeyRef.ref.join('_')}`;
-        newForeignKey(fkArtifact, foreignKeyElementName);
-      }
-    }
-
-    return generatedFks;
-
-    function processStucturedKey(fkArtifact, assocName, foreignKeyRef) {
-      const subStruct = fkArtifact.elements ? fkArtifact : csnUtils.getFinalBaseType(fkArtifact.type);
-      const flatElements = flattenStructure(subStruct.elements, subStruct.$path, csnUtils, options, error, undefined, fkArtifact.$path.slice(-1) || []).newFlatElements;
-      for (const [flatElemName, flatElem] of Object.entries(flatElements)) {
-        const foreignKeyElementName =
-          `${assocName.replace(/\./g, '_')}_${foreignKeyRef.as ? flatElemName.replace(implicitAs(foreignKeyRef.ref), foreignKeyRef.as) : flatElemName}`;
-        newForeignKey(flatElem, foreignKeyElementName);
-      }
-    }
-
-    function newForeignKey(fkArtifact, foreignKeyElementName) {
-      if (fkArtifact.type === 'cds.Association' || fkArtifact.type === 'cds.Composition') {
-        processAssociationOrComposition(fkArtifact, foreignKeyElementName);
-        return;
-      }
-
-      // FIXME: better use transformUtlsNew::createRealFK(...);
-      let foreignKeyElement = Object.create(null);
-
-      // Transfer selected type properties from target key element
-      // FIXME: There is currently no other way but to treat the annotation '@odata.Type' as a type property.
-      for (let prop of ['type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type']) {
-        if (fkArtifact[prop] !== undefined) {
-          foreignKeyElement[prop] = fkArtifact[prop];
-        }
-      }
-      // If the association is non-fkArtifact resp. key, so should be the foreign key field
-      for (let prop of ['notNull', 'key']) {
-        if (assoc[prop] !== undefined) {
-          foreignKeyElement[prop] = assoc[prop];
-        }
-      }
-
-      foreignKeyElement['@odata.foreignKey4'] = foreignKey4;
-      if (flatKeys) foreignKeyRef.$generatedFieldName = foreignKeyElementName;
-      setProp(foreignKeyElement, '$path', pathInKeysArr); // attach $path to the newly created element - used for inspectRef in processAssociationOrComposition
-      if (assoc.$location) {
-        setProp(foreignKeyElement, '$location', assoc.$location);
-      }
-      generatedFks[foreignKeyElementName] = foreignKeyElement;
-    }
-
-    function processAssociationOrComposition(fkArtifact, foreignKeyElementName) {
-      fkArtifact.keys.forEach((keyRef,keyId) => {
-        const path = fkArtifact.$path.concat('keys').concat(keyId);
-        const fksForAssoc = generateForeignKeysForRef(assoc, foreignKeyElementName, keyRef, path, foreignKey4);
-        Object.assign(generatedFks, fksForAssoc);
-      })
-    }
-  }
-}
-
-/**
- *
- * @param {object} obj
- * @param {*} other
- * @returns {boolean} Whether 'obj' and 'other' are deeply equal. We need the
- * deep comparison because of annotations that have structured values and they
- * are propagated to the generated foreign keys.
- */
-function isDeepEqual(obj, other) {
-  const objectKeys = Object.keys(obj);
-  const otherKeys = Object.keys(other);
-
-  if (objectKeys.length !== otherKeys.length)
-    return false;
-
-  for (let key of objectKeys) {
-    const areValuesObjects = (obj[key] != null && typeof obj[key] === 'object')
-      && (other[key] !== null && typeof other[key] === 'object');
-
-    if (areValuesObjects) {
-      if (!isDeepEqual(obj[key], other[key]))
-        return false;
-    } else if (obj[key] !== other[key]) {
-      return false;
-    }
-  }
-  return true;
-}

package/lib/transform/odata/referenceFlattener.js

@@ -1,296 +0,0 @@
-const { applyTransformations } = require('../../model/csnUtils');
-const { setProp } = require('../../base/model');
-const { implicitAs } = require('../../model/csnRefs');
-const { structuralPath } = require('./structuralPath');
-
-/** This class is used for generic reference flattening.
- * It provides the following functionality:
- * - attach the CSN location paths of object as $path property
- * - resolve all references found in the CSN
- * The resolved references and their paths are stored in the $paths property which is attached to the reference
- * In addition, the items of the references will be checked if they point to structured elements,
- * and the result will be cached in the "structuredReference" member variable.
- * - register flattened elements - stored in the member variable "flattenedElementPaths"
- * - check if a specific path points to a structured element
- * - flatten of all references - combines already stored information to flatten the references
- *
- * Generic reference flattening works as follows:
- * - resolve all references and there the single items
- * - attach the resolved paths to the elements
- * - during flattening of elements, transformers register all flattened paths
- * - final flattening detects reference items which point to flattened elements
- *   and joins both previous and current reference items
- *
- * Element transitions - when a structure is flattened, elements are moved from one location to another.
- * Those transitions are registered in elementTransitions, where the origin path as key is mapped to the new path location.
- * Used structure: elementTransitions[fromPath.toString()]=toPath.asPath()
- * The key is the origin path joined with slash, new path is stored as path - array of strings.
- * The corresponding functions are: registerElementTransition and getElementTransition.
- */
-
-class ReferenceFlattener {
-
-  /**
-   * Reference flattening helper.
-   * @constructor
-   */
-  constructor() {
-    this.flattenedElementPaths = {};
-    this.structuredReference = {};
-    this.generatedElementsForPath = {};
-    this.elementTransitions = {};
-    this.elementNamesWithDots = {};
-  }
-
-  /**
-   * Resolves all references in the specified CSN and attaches the paths of resolved reference items
-   * as non-enumerable array of paths property called $paths.
-   * In addition stores information in structuredReference about each item in a reference if it points to a structered element in the CSN.
-   *
-   * @param {*} csn Specifies the CSN to process.
-   * @param {*} inspectRef Callback function performing the inspection of the references.
-   * @param {*} isStructured Callback function checking of an artifact is a structured element.
-   */
-  resolveAllReferences(csn, inspectRef, isStructured) {
-    applyTransformations(csn, {
-      ref: (node, prop, _ref, path) => {
-        if (!path) return;
-        let resolved;
-        try {
-          resolved = inspectRef(path);
-        } catch (ex) {
-          return;  // TODO: fix tests: throw Error("Could not inspectRef: " + path.join("/"));
-        }
-        if (!resolved)
-          return; // TODO: fix tests: throw Error("Could not resolve: " + path.join("/"));
-        if (!resolved.links)
-          return; // TODO: fix tests:  throw Error("Could not resolve links: " + path.join("/"));
-        let paths = [];
-        resolved.links.forEach((element) => {
-          if (!element.art)
-            paths = undefined; // not resolved -> no paths
-          if (paths) {
-            paths.push(element.art.$path);
-          }
-        });
-        if (paths)
-          setProp(node, '$paths', paths);
-        // cache if structured or not
-        let structured = resolved.links.map(link => link.art ? (isStructured(link.art)) : undefined);
-        this.structuredReference[path.join('/')] = structured;
-      }
-    })
-  }
-
-  /**
-   * Checks if the provided path identifies a structured node in a CSN.
-   * It reuses the information collected from the resolveAllReferences function.
-   *
-   * @param {Array.<string>} path Array of node names identifying a node in a CSN.
-   * @returns {boolean}
-   */
-  isStructured(path) {
-    return this.structuredReference[path.join('/')];
-  }
-
-  /**
-   * During flattening of structured elements in a CSN,
-   * leaf-nodes are moved in the root the the artifact.
-   * This information is stored in form of source and target paths.
-   *
-   * @param {Array.<string>} fromPath Path of the source location.
-   * @param {Array.<string>} toPath Path of the destination location.
-   */
-  registerElementTransition(fromPath, toPath) {
-    let sFromPath = fromPath.join('/');
-    let sToPath = toPath.join('/');
-    if (sFromPath === sToPath) return; // same path -> no transition
-    this.elementTransitions[sFromPath] = toPath;
-  }
-
-  /**
-   * For specified path of a node in CSN,
-   * returns the transition path where the element was moved during the structure flattening.
-   * It reuses the collected information from function registerElementTransition.
-   *
-   * @param {Array.<string>} path The originating path of the node of interest.
-   * @returns {Array.<string>} The path of the target location in case of element transition.
-   */
-  getElementTransition(path) {
-    let sPath = path.join('/');
-    return this.elementTransitions[sPath];
-  }
-
-  /**
-   * During structure flattening inner structures will be joined.
-   * Each element joined with its children will be registered using its path in the CSN tree.
-   * This information will be used in the reference flattener to identify which items to join.
-   *
-   * @param {Array.<string>} path Path of the element in the CSN tree.
-   * @param {Array.<string>} originPath Path of the originating element.
-   */
-  registerFlattenedElement(path, originPath) {
-    let spath = path.join('/');
-    this.flattenedElementPaths[spath] = true;
-    if (originPath) {
-      let sOriginPath = originPath.join('/');
-      this.flattenedElementPaths[sOriginPath] = true;
-    }
-  }
-
-  /**
-   * During the flattening of structured elements new elements will be produced.
-   * The list of the new elements is stored under the path of the originating element used as key.
-   * The information will be used by the foreign key processing module.
-   *
-   * @param {Array.<string>} path Path of originating element.
-   * @param {Array.<string>} elementNames List of generated element names.
-   */
-  registerGeneratedElementsForPath(path, elementNames) {
-    this.generatedElementsForPath[path.join('/')] = elementNames;
-  }
-
-  /**
-   * Provides information about all generated elements for specific path in the CSN tree.
-   *
-   * @param {Array.<string>} path Path of the element to get the generated elements for.
-   * @returns {Array.<string>} List of generated names for the specified element path.
-   */
-  getGeneratedElementsForPath(path) {
-    return this.generatedElementsForPath[path.join('/')];
-  }
-
-  setElementNameWithDots(path, elementNameWithDots) {
-    this.elementNamesWithDots[path.join('/')] = elementNameWithDots;
-  }
-
-  getElementNameWithDots(path) {
-    return this.elementNamesWithDots[path.join('/')];
-  }
-
-  /**
-   * Generic reference flattener as {@link ReferenceFlattener described}.
-   *
-   * @param {*} csn
-   */
-  flattenAllReferences(csn) {
-    applyTransformations(csn, {
-      ref: (node, prop, ref, path) => {
-        if (node.$paths) {
-          let newRef = []; // flattened reference
-          let flattenWithPrevious = false;
-          let lastFlattenedID = null; // The variable will be set to the index of the last flattened path
-          node.$paths.forEach((path, i) => {
-            if (path === undefined || !ref[i]) return;
-            let spath = path.join('/');
-            let movedTo = this.elementTransitions[spath]; // detect element transition
-            let flattened = this.flattenedElementPaths[spath];
-            if (flattenWithPrevious) {
-              newRef[newRef.length - 1] = newRef[newRef.length - 1] + '_' + (ref[i].id || ref[i]);
-              // if we have a filter or args in an assoc, it needs to be kept, therefore
-              // the id of the ref is updated with the flattened version
-              if (ref[i].id) {
-                ref[i].id = newRef[newRef.length - 1];
-                newRef[newRef.length - 1] = ref[i];
-              }
-              lastFlattenedID = i;
-            } else if(movedTo && i===0) { // handle local scope reference which is transitioned - replace first item in reference
-              let movedToElementName = movedTo[movedTo.length-1];
-              newRef.push(movedToElementName);
-              lastFlattenedID = i;
-            } else {
-              newRef.push(ref[i]);
-            }
-            flattenWithPrevious = flattened;
-          });
-          if (newRef !== undefined && lastFlattenedID !== null) { // make sure the reference changed and only then replace it with the new one
-            // check if this is a column and add alias if missing
-            let structural = structuralPath(csn, path);
-            if (isColumnInSelectOrProjection(structural)) {
-              if (!node.as && lastFlattenedID === ref.length-1) // attach alias only if there is none and it is the last item in the reference that was flattened
-                node.as = node.ref[node.ref.length - 1];
-            }
-            setProp(newRef, '$path', path.concat('ref'));
-            if (!node.as) {
-              if (isPartOfKeysStructure(structural))
-                node.as = implicitAs(node.ref);
-              else
-                setProp(node, 'as', implicitAs(node.ref))
-            }
-            node.ref = newRef;
-          }
-        }
-      }
-    })
-  }
-
-  applyAliasesInOnCond(csn, inspectRef) {
-    applyTransformations(csn, {
-      ref: (node, prop, ref, path) => {
-        // Process only on-conditions of associations
-        let structural = structuralPath(csn, path);
-        if(!isOnCondition(structural)) return;
-        let { links } = inspectRef(path);
-        if(!links) return; // $user not resolvable
-        let keysOfPreviousStepWhenManagedAssoc = undefined;
-  
-        let aliasedRef = [...ref];
-  
-        for (let idx = 0; idx < ref.length; idx++) {
-          const currArt = links[idx].art;
-          if (keysOfPreviousStepWhenManagedAssoc) {
-            const usedKey = keysOfPreviousStepWhenManagedAssoc.find(key => key.ref[0] === ref[idx]);
-            if (usedKey && usedKey.as) {
-              aliasedRef.splice(idx, usedKey.ref.length, usedKey.as);
-              idx += usedKey.ref.length - 1;
-              keysOfPreviousStepWhenManagedAssoc = undefined;
-            }
-          } else {
-            keysOfPreviousStepWhenManagedAssoc =
-              (currArt.type === 'cds.Association' || currArt.type === 'cds.Composition') && currArt.keys;
-          }
-        }
-        node.ref = aliasedRef;
-      }
-    })
-  }
-}
-
-/**
- * Checks if the provided path is a column inside a key node
- * by exploring the possibility of the structural path to  ends with 'elements' and 'keys'.
- *
- * @param structural structural path to explore
- * @returns {boolean} True if the provided path matched the requirements to be part of a key node.
- */
-function isPartOfKeysStructure(structural) {
-  return structural[structural.length-2] === 'elements'
-      && structural[structural.length-1] === 'keys';
-}
-
-/**
- * Checks if the provided path is a column inside a select or a projection node
- * by exploring the possibility of the structural path to contain 'SELECT' or 'projection'
- * and ends with 'columns' or 'columns' and 'expand'.
- *
- * @param structural structural path to explore
- * @returns {boolean} True if the provided path matched the requirements to be a select node.
- */
-function isColumnInSelectOrProjection(structural) {
-  return (structural.includes('SELECT') ||  structural.includes('projection'))
-    && (structural[structural.length-1] === 'columns' || (structural[structural.length-2] === 'columns' && structural[structural.length-1] === 'expand'));
-}
-
-/**
- * Checks if the provided path is a column inside an on-condition of an element
- * by exploring the possibility of the structural path to  ends with 'elements' and 'on'.
- *
- * @param structural structural path to explore
- * @returns {boolean} True if the provided path matched the requirements to be part of an element's on-condition.
- */
-function isOnCondition(structural) {
-  return structural[structural.length-2] === 'elements'
-      && structural[structural.length-1] === 'on';
-}
-
-module.exports = ReferenceFlattener;