@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/transform/odata/referenceFlattener.js

@@ -1,290 +0,0 @@
-const { forEachRef } = 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) {
-    forEachRef(csn, (_ref, node, 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) {
-    forEachRef(csn, (ref, node, 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) {
-    forEachRef(csn, (ref, node, 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;

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' && definition.kind !== 'view')
-    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 };