@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/transform/odata/sortByAssociationDependency.js

@@ -1,105 +0,0 @@
-'use strict';
-
-/**
- * In the OData transformer, managed associations produce foreign keys.
- * If an association is also a primary key, the additionally created foreign keys become also primary keys in the parent artifact.
- * Associations with partial foreign keys force other non-key elements and associations to become virtual primary keys.
- * Proper FK generation requires specific order of performing that.
- * This module provides functionality to sort managed associations according to their dependencies.
- */
-
-const {
-  forEachDefinition,
-  forEachMemberRecursively
-} = require('../../model/csnUtils');
-
-const {
-  isAssociationOrComposition
-} = require('./utils');
-const { forEach } = require('../../utils/objectUtils.js');
-
-function buildDependenciesFor(csn, referenceFlattener, isExternalServiceMember) {
-
-  let dependencies = {};
-  forEachDefinition(csn, (def, definitionName) => {
-    /** @type {CSN.Path} */
-    let root = ['definitions', definitionName];
-    forEachMemberRecursively(def, (element, elementName, structuralNodeName, subpath, parent) => {
-      let path = root.concat(subpath);
-      // go only through managed associations and compositions
-      if (isAssociationOrComposition(element) && element.keys && !element.on) { // check association FKs
-        let elementDependencies = []
-        element.keys.forEach(iForeignKey => {
-          let paths = iForeignKey.$paths;
-          if (!paths) return; // invalid references can not be resolved thus no $paths -> test/odataTransformation/negative/ForeignKeys.cds
-          let targetElementPath = paths[paths.length - 1];
-          if (!targetElementPath) return; // TODO check why
-          let targetElement = getElementForPath(csn, targetElementPath);
-          if (!targetElement) { // element was moved
-            targetElementPath = referenceFlattener.getElementTransition(targetElementPath);
-            if (!targetElementPath) return; // TODO check why
-            targetElement = getElementForPath(csn, targetElementPath);
-          }
-          if (targetElement && isAssociationOrComposition(targetElement)) {
-            elementDependencies.push(targetElementPath);
-          }
-        })
-        dependencies[path.join("/")] = { structuralNodeName, definitionName, elementName, element, path, parent, dependencies: elementDependencies };
-      }
-    }) // forEachMemberRecursively
-  }, { skipArtifact: isExternalServiceMember }) // forEachDefinition
-
-  let result = []; // final list of sorted association items
-  let inResult = {}; // paths of associations which were added in the result
-  let maxLoops = Object.keys(dependencies).length;
-  let loops = 0;
-  let done = false;
-  // walk over all dependencies and add to the result if all dependents are already in the result
-  while (!done) {
-    if (loops > maxLoops) {
-      throw Error('Failed to process the association dependencies - max loops reached');
-    }
-    done = true;
-    let toDelete = [];
-    forEach(dependencies, (name, item) => {
-      let countOfUnprocessedDependents = 0;
-      item.dependencies.forEach(path => {
-        let spath = path.join('/');
-        if (!inResult[spath]) countOfUnprocessedDependents++;
-      })
-      if (countOfUnprocessedDependents === 0) { // all dependents processed?
-        let spath = item.path.join('/');
-        if (!inResult[spath]) {
-          inResult[spath] = true;
-          result.push(item);
-        }
-        toDelete.push(name); // mark association to be removed from the processing list
-      } else {
-        done = false;
-      }
-    })
-    // delete already processed associations
-    toDelete.forEach(name => {
-      delete dependencies[name];
-    });
-    loops++;
-  } // while not done
-
-  // check if all dependencies were processed
-  if (Object.keys(dependencies).length !== 0) {
-    throw Error('Failed to process the association dependencies - there are more dependencies left');
-  }
-  return result;
-
-  function getElementForPath(node, path) {
-    path.forEach(name => {
-      if (!node) return;
-      node = node[name];
-    })
-    return node;
-  }
-
-}
-
-module.exports = buildDependenciesFor
-

package/lib/transform/odata/structuralPath.js

@@ -1,72 +0,0 @@
-// The module traverses a given CSN using a specific path, collects structural node names and returns them.
-
-const structuralNodeHandlers = {
-  definitions: traverseDict,
-  elements: traverseDict,
-  actions: traverseDict,
-  params: traverseDict,
-  items: traverseTyped,
-  enum: traverseDict,
-  returns: traverseTyped,
-  on: traverseArray,
-  keys: traverseArray,
-  ref: traverseArray,
-  query: traverseTyped,
-  SELECT: traverseTyped,
-  SET: traverseTyped,
-  args: traverseArray,
-  columns: traverseArray,
-  projection: traverseTyped,
-  from: traverseTyped,
-  mixin: traverseDict,
-  where: traverseArray,
-  orderBy: traverseArray,
-  groupBy: traverseArray,
-  having: traverseArray,
-  xpr: traverseArray,
-  expand: traverseArray,
-  inline: traverseArray,
-  cast: traverseTyped,
-}
-
-function structuralPath(csn, path) {
-  return traverseDict(csn.definitions, path, 1, ['definitions']);
-}
-
-function traverseArray(obj, path, index, typeStack) {
-  if(!Array.isArray(obj)) return typeStack;
-  const name = path[index];
-  const element = obj[name];
-  return traverseTyped(element, path, index+1, typeStack);
-}
-
-function traverseDict(obj, path, index, typeStack) {
-  if(typeof obj !== 'object') return typeStack;
-  const name = path[index];
-  if(name === undefined) return typeStack;
-  return traverseTyped(obj[name], path, index+1, typeStack);
-}
-
-function traverseDictArray(obj, path, index, typeStack) {
-  if(typeof obj !== 'object') return typeStack;
-  const name = path[index];
-  if(name === undefined) return typeStack;
-  return traverseArray(obj[name], path, index+1, typeStack);
-}
-
-function traverseTyped(obj, path, index, typeStack) {
-  if(!obj) return typeStack;
-  const name = path[index];
-  if(name === undefined) return typeStack;
-  if(name[0] === '@') return typeStack; // skip annotations
-  const func = structuralNodeHandlers[name];
-  if(func) return func(obj[name], path, index+1, typeStack.concat(name));
-  // not typed -> columns?
-  if(typeStack[typeStack.length-1] === 'columns')
-    return traverseDictArray(obj, path, index, typeStack);
-  return typeStack;
-}
-
-module.exports = {
-  structuralPath
-}

package/lib/transform/odata/structureFlattener.js

@@ -1,171 +0,0 @@
-'use strict';
-
-const { copyAnnotations } = require('../../model/csnUtils');
-const { cloneCsn, forEachDefinition } = require('../../model/csnUtils');
-const { attachPathOnPartialCSN } = require('./attachPath');
-
-// These functions are used for propagation of the annotations, virtual, key,
-// notNull attributes collected along the path during flattening.
-const { addPropsForPropagationFromElement, propagatePropsToElement, resetPropsForPropagation } = function () {
-  let toBePropagated = Object.create(null);
-  return {
-    addPropsForPropagationFromElement: function (element) {
-      copyAnnotations(element, toBePropagated);
-      if (element.virtual) toBePropagated.virtual = element.virtual;
-      if (element.key) toBePropagated.key = element.key;
-    },
-    propagatePropsToElement: function (element) {
-      copyAnnotations(toBePropagated, element);
-      if (toBePropagated.virtual) element.virtual = toBePropagated.virtual;
-      if (toBePropagated.key) element.key = toBePropagated.key;
-    },
-    resetPropsForPropagation: function () {
-      toBePropagated = Object.create(null);
-    }
-  }
-}();
-
-// keep here the state of the 'notNull' attribute
-// this is needed because during flattening all the elements
-// along the chain need to be assigned with not null so
-// the resulting element to be not null as well
-const { isNotNull, setNotNull, setUpNotNull } = function () {
-  let notNull = undefined;
-  return {
-    isNotNull: function () {
-      return notNull;
-    },
-    setNotNull: function (value) {
-      notNull = value;
-    },
-    setUpNotNull: function (element, isParentNotNull) {
-      if (isParentNotNull && element.notNull) setNotNull(element.notNull);
-      else if (isNotNull() && !element.notNull || (isNotNull() === false && element.notNull !== false)) setNotNull(undefined);
-    }
-  }
-}();
-
-/**
- * During the OData transformations in flat-mode, all structured elements will be flattened.
- * This module performs the complete flattening.
- * It also provides information to the reference flattener: elements produced for specific path in the CSN structure.
- * @param {CSN.Model} csn CSN-object to flatten
- * @param {*} csnUtils instances of utility functions
- * @param {*} options
- * @param {*} referenceFlattener
- * @param {Function} error
- * @param {Function} isExternalServiceMember returns true for an artifact that is part of an external service
- */
-function flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExternalServiceMember) {
-  forEachDefinition(csn, (def, defName, propertyName, path) =>
-    flattenDefinition(def, path, csnUtils, options, referenceFlattener, error), { skipArtifact: isExternalServiceMember });
-}
-
-/**
- * Flattens one single definition and all structures in it. Modifies the definition in place.
- * @param {CSN.Definition} definition definition object to flatten
- * @param {CSN.Path} definitionPath path in CSN object
- * @param {*} csnUtils utility functions
- * @param {*} options
- * @param {*} referenceFlattener
- * @param {Function} error
- */
-function flattenDefinition(definition, definitionPath, csnUtils, options, referenceFlattener, error) {
-  if (definition.kind !== 'entity')
-    return;
-
-  let { newFlatElements } = flattenStructure(definition.elements, definitionPath, csnUtils, options, error, referenceFlattener);
-
-  attachPathOnPartialCSN(newFlatElements, definitionPath.concat('elements'));
-  definition.elements = newFlatElements;
-
-  if (definition.params) {
-    let { newFlatElements } = flattenStructure(definition.params, definitionPath, csnUtils, options, error, referenceFlattener);
-    attachPathOnPartialCSN(newFlatElements, definitionPath.concat('params'));
-    definition.params = newFlatElements;
-  }
-} // flattenDefinition
-
-/**
- * Flattens structured element by calling element flattener for each structured child.
- * Returns a dictionary containing all the new elements for the given structure.
- * @param {*} dictionary to flatten
- * @param {CSN.Path} path the path of the structure in the CSN tree
- * @param {*} csnUtils
- * @param {Function} error Error message function
- * @param {*} [referenceFlattener]
- * @param {string[]} [elementPathInStructure] list of parent element names
- * @param {*} [newFlatElements]
- * @param {boolean} [isTopLevelElement] states if this is a top level element
- */
-function flattenStructure(dictionary, path, csnUtils, options, error, referenceFlattener = undefined, elementPathInStructure = [],
-  newFlatElements = Object.create(null), isTopLevelElement = true, isParentNotNull = false) {
-
-  if (!isTopLevelElement) addPropsForPropagationFromElement(dictionary);
-
-  let generatedNewFlatElementsNames = []; // holds the names of all new child elements of the structure
-
-  dictionary && Object.entries(dictionary).forEach(([elementName, element]) => {
-    let currPath = path.concat('elements', elementName);
-
-    if (isTopLevelElement) {
-      resetPropsForPropagation();
-      setNotNull(element.notNull)
-    } else {
-      setUpNotNull(element, isParentNotNull);
-    }
-
-    // flat elements when structured and NOT empty (allow incomplete structures - cds-compiler#4337)
-    if (csnUtils.isStructured(element) && !(element.elements && Object.keys(element.elements).length === 0)) {
-
-      if (referenceFlattener) referenceFlattener.registerFlattenedElement(currPath, element.$path);
-
-      addPropsForPropagationFromElement(element);
-
-      // if the child element is structured itself -> needs to be flattened
-      const elements = element.elements || csnUtils.getFinalBaseType(element.type).elements;
-      let result = flattenStructure(elements, currPath, csnUtils, options, error, referenceFlattener, elementPathInStructure.concat(elementName), newFlatElements, false, isNotNull());
-      generatedNewFlatElementsNames.push(...result.generatedNewFlatElementsNames); // accomulate names of produced elements
-
-    } else { // when we do not need to flat, this is scalar or empty (cds-compiler#4337) -> needs to be registered in referenceFlattener
-      let newElementName = elementPathInStructure.concat(elementName).join('_');
-      let elementNameWithDots = elementPathInStructure.concat(elementName).join('.');
-      addNewElementToResult(element, newElementName, elementNameWithDots, currPath);
-    }
-  });
-
-  if (referenceFlattener) {
-    referenceFlattener.registerGeneratedElementsForPath(path, generatedNewFlatElementsNames);
-  }
-  return { newFlatElements, generatedNewFlatElementsNames };
-
-  // adds newly created element into the final dictionary of elements
-  function addNewElementToResult(element, elementName, elementNameWithDots, path) {
-    if (newFlatElements[elementName]) {
-      error(null, path, `Generated element ${elementName} conflicts with other generated element`);
-    } else {
-      let newPath = path.slice(0, 2).concat('elements', elementName);
-      let newElement = createNewElement(element, elementNameWithDots, newPath);
-      newFlatElements[elementName] = newElement;
-      generatedNewFlatElementsNames.push(elementName);
-
-      if (referenceFlattener) {
-        referenceFlattener.registerElementTransition(path, newPath);
-      }
-    }
-  } // addNewElementToResult
-
-  // creates new element by copying the properties of the originating element
-  function createNewElement(element, elementNameWithDots, path) {
-    let newElement = cloneCsn(element, options);
-    if (!isTopLevelElement) propagatePropsToElement(newElement);
-    if (isNotNull() === undefined) delete newElement.notNull;
-    if (!isTopLevelElement && referenceFlattener) {
-      referenceFlattener.setElementNameWithDots(path, elementNameWithDots);
-    }
-    return newElement;
-  } // createNewElement
-
-} // flattenStructure
-
-module.exports = { flattenCSN, flattenStructure };