@sap/cds-compiler 2.11.2 → 2.11.4

package/lib/transform/db/applyTransformations.js

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * Module for general (partial) CSN looper functions, respecting dictionaries and allowing
+ * to pass custom callbacks for certain properties like "ref".
+ *
+ * Functions are also published in csnUtils.js for convenience.
+ *
+ * They should stay here due to the stricter linter rules for the time being.
+ *
+ * @module lib/transform/db/applyTransformations
+ */
+const { setProp } = require('../../base/model');
+
+
+/**
+ * @param {object} parent The "parent" of which we transform a property of
+ * @param {string} prop The property of parent to start at
+ * @param {object} customTransformers Map of prop to transform and function to apply
+ * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
+ * @param {boolean} [skipIgnore=true] Wether to skip _ignore elements or not
+ * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
+ * @param {CSN.Path} path Path to parent
+ * @returns {object} parent with transformations applied
+ */
+function applyTransformationsInternal(parent, prop, customTransformers, artifactTransformers, skipIgnore, options, path = []) {
+  const transformers = {
+    elements: dictionary,
+    definitions: dictionary,
+    actions: dictionary,
+    params: dictionary,
+    enum: dictionary,
+    mixin: dictionary,
+    ref: pathRef,
+  };
+
+  const csnPath = [ ...path ];
+  if (prop === 'definitions')
+    definitions( parent, 'definitions', parent.definitions );
+  else
+    standard(parent, prop, parent[prop]);
+  return parent;
+
+  /**
+   * Default transformer for things that are not dictionaries, like "type" or "keys".
+   * The customTransformers are applied here (and only here).
+   *
+   * @param {object | Array} _parent the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {object} node The value of node[_prop]
+   */
+  function standard( _parent, _prop, node ) {
+    if (!node || typeof node !== 'object' || !{}.propertyIsEnumerable.call( _parent, _prop ) || (typeof _prop === 'string' && _prop.startsWith('@')) || (skipIgnore && node._ignore))
+      return;
+
+    csnPath.push( _prop );
+
+    if (Array.isArray(node)) {
+      node.forEach( (n, i) => standard( node, i, n ) );
+    }
+
+    else {
+      for (const name of Object.getOwnPropertyNames( node )) {
+        const trans = transformers[name] || standard;
+        if (customTransformers[name])
+          customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
+
+        trans( node, name, node[name], csnPath );
+      }
+    }
+    csnPath.pop();
+  }
+
+  /**
+   * Transformer for things that are dictionaries - like "elements".
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {object} dict The value of node[_prop]
+   */
+  function dictionary( node, _prop, dict ) {
+    // Allow skipping dicts like actions in forHanaNew
+    if (options.skipDict && options.skipDict[_prop])
+      return;
+    csnPath.push( _prop );
+    for (const name of Object.getOwnPropertyNames( dict ))
+      standard( dict, name, dict[name] );
+
+    if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
+      setProp(node, `$${_prop}`, dict);
+    csnPath.pop();
+  }
+
+  /**
+   * Special version of "dictionary" to apply artifactTransformers.
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {object} dict The value of node[_prop]
+   */
+  function definitions( node, _prop, dict ) {
+    csnPath.push( _prop );
+    for (const name of Object.getOwnPropertyNames( dict )) {
+      const skip = options && options.skipArtifact && options.skipArtifact(dict[name], name) || false;
+      if (!skip) {
+        artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
+        standard( dict, name, dict[name] );
+      }
+    }
+    if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
+      setProp(node, `$${_prop}`, dict);
+    csnPath.pop();
+  }
+
+  /**
+   * Keep looping through the pathRef - because in a .ref we can have .args and .where
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {any} _path The value of node[_prop]
+   */
+  function pathRef( node, _prop, _path ) {
+    csnPath.push( _prop );
+    _path.forEach( ( s, i ) => {
+      if (s && typeof s === 'object') {
+        csnPath.push( i );
+        if (options.drillRef) {
+          standard(_path, i, s);
+        }
+        else {
+          if (s.args)
+            standard( s, 'args', s.args );
+          if (s.where)
+            standard( s, 'where', s.where );
+        }
+        csnPath.pop();
+      }
+    } );
+    csnPath.pop();
+  }
+}
+
+/**
+ * Loop through the model, applying the custom transformations on the node's matching.
+ *
+ * Each transformer gets:
+ * - the parent having the property
+ * - the name of the property
+ * - the value of the property
+ * - the path to the property
+ *
+ * @param {object} csn CSN to enrich in-place
+ * @param {object} customTransformers Map of _prop to transform and function to apply
+ * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
+ * @param {boolean} [skipIgnore=true] Wether to skip _ignore elements or not
+ * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
+ * @returns {object} CSN with transformations applied
+ */
+function applyTransformations( csn, customTransformers = {}, artifactTransformers = [], skipIgnore = true, options = {} ) {
+  if (csn && csn.definitions)
+    return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, skipIgnore, options);
+  return csn;
+}
+
+
+/**
+ * Instead of looping through the whole model, start at a given thing (like an on-condition),
+ * as long as it is not a dictionary.
+ *
+ * Each transformer gets:
+ * - the parent having the property
+ * - the name of the property
+ * - the value of the property
+ * - the path to the property
+ *
+ * @param {object} parent The "parent" of which we transform a property of
+ * @param {string} prop The property of parent to start at
+ * @param {object} customTransformers Map of prop to transform and function to apply
+ * @param {CSN.Path} path Path pointing to parent
+ * @returns {object} parent[prop] with transformations applied
+ */
+function applyTransformationsOnNonDictionary(parent, prop, customTransformers = {}, path = []) {
+  return applyTransformationsInternal(parent, prop, customTransformers, [], true, {}, path)[prop];
+}
+
+module.exports = {
+  applyTransformations,
+  applyTransformationsOnNonDictionary,
+};

package/lib/transform/db/flattening.js

@@ -14,7 +14,7 @@ const { setProp } = require('../../base/model');
  * @param {CSN.Model} csn
  */
 function removeLeadingSelf(csn) {
-  const magicVars = [ '$now' ];
+  const magicVars = [ '$now', '$self', '$projection', '$user', '$session', '$at' ];
   forEachDefinition(csn, (artifact, artifactName) => {
     if (artifact.kind === 'entity' || artifact.kind === 'view') {
       forAllElements(artifact, artifactName, (parent, elements) => {

package/lib/transform/db/transformExists.js

@@ -51,6 +51,9 @@ function handleExists(csn, options, error) {
   const { inspectRef } = csnRefs(csn);
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
+    if (artifact.projection) // do the same hack we do for the other stuff...
+      artifact.query = { SELECT: artifact.projection };
+
     if (artifact.query) {
       forAllQueries(artifact.query, (query, path) => {
         if (!generatedExists.has(query)) {
@@ -83,6 +86,12 @@ function handleExists(csn, options, error) {
         }
       }, [ 'definitions', artifactName, 'query' ]);
     }
+
+    if (artifact.projection) { // undo our hack
+      artifact.projection = artifact.query.SELECT;
+
+      delete artifact.query;
+    }
   });
 
   /**

package/lib/transform/db/views.js

@@ -1,10 +1,62 @@
 'use strict';
 
-const { usesMixinAssociation, getMixinAssocOfQueryIfPublished } = require('./helpers');
-const { getUtils, cloneCsn } = require('../../model/csnUtils');
+const {
+  getUtils, cloneCsn, applyTransformationsOnNonDictionary,
+} = require('../../model/csnUtils');
 const { implicitAs, csnRefs } = require('../../model/csnRefs');
 const { isBetaEnabled } = require('../../base/model');
 
+/**
+ * If a mixin association is published, return the mixin association.
+ *
+ * @param {CSN.Query} query Query of the artifact to check
+ * @param {object} association Association (Element) published by the view
+ * @param {string} associationName
+ * @returns {object} The mixin association
+ */
+function getMixinAssocOfQueryIfPublished(query, association, associationName) {
+  if (query && query.SELECT && query.SELECT.mixin) {
+    const aliasedColumnsMap = Object.create(null);
+    if (query.SELECT.columns) {
+      for (const column of query.SELECT.columns) {
+        if (column.as && column.ref && column.ref.length === 1)
+          aliasedColumnsMap[column.as] = column;
+      }
+    }
+
+    for (const elem of Object.keys(query.SELECT.mixin)) {
+      const mixinElement = query.SELECT.mixin[elem];
+      let originalName = associationName;
+      if (aliasedColumnsMap[associationName])
+        originalName = aliasedColumnsMap[associationName].ref[0];
+
+      if (elem === originalName)
+        return { mixinElement, mixinName: originalName };
+    }
+  }
+  return {};
+}
+
+/**
+ * Check wether the given artifact uses the given mixin association.
+ *
+ * We can rely on the fact that there can be no usage starting with $self/$projection,
+ * since lib/checks/selectItems.js forbids that.
+ *
+ * @param {CSN.Query} query Query of the artifact to check
+ * @param {object} association Mixin association (Element) to check for
+ * @param {string} associationName
+ * @returns {boolean} True if used
+ */
+function usesMixinAssociation(query, association, associationName) {
+  if (query && query.SELECT && query.SELECT.columns) {
+    for (const column of query.SELECT.columns) {
+      if (typeof column === 'object' && column.ref && column.ref.length > 1 && (column.ref[0] === associationName || column.ref[0].id === associationName))
+        return true;
+    }
+  }
+  return false;
+}
 
 /**
  * @param {CSN.Model} csn
@@ -15,7 +67,7 @@ const { isBetaEnabled } = require('../../base/model');
  */
 function getViewTransformer(csn, options, messageFunctions, transformCommon) {
   const {
-    get$combined, cloneWithTransformations, isAssocOrComposition,
+    get$combined, isAssocOrComposition,
   } = getUtils(csn);
   const { inspectRef, queryOrMain } = csnRefs(csn);
   const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
@@ -181,41 +233,38 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
    * create the __clone for publishing stuff.
    *
    * @todo Factor out the checks
-   * @todo Union, Join, Subqueries? Assoc usage in there? __clone?
    * @param {CSN.Query} query
    * @param {object} elements
    * @param {object} columnMap
    * @param {WeakMap} publishedMixins Map to collect the published mixins
    * @param {CSN.Element} elem
    * @param {string} elemName
-   * @param {CSN.Path} path
+   * @param {CSN.Path} elementsPath Path pointing to elements
+   * @param {CSN.Path} queryPath Path pointing to the query
    */
-  function handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, path) {
-    if (isUnion(path) && options.transformation === 'hdbcds') {
+  function handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, elementsPath, queryPath) {
+    if (isUnion(queryPath) && options.transformation === 'hdbcds') {
       if (isBetaEnabled(options, 'ignoreAssocPublishingInUnion') && doA2J) {
         if (elem.keys)
-          info(null, path, `Managed association "${elemName}", published in a UNION, will be ignored`);
+          info(null, queryPath, `Managed association "${elemName}", published in a UNION, will be ignored`);
         else
-          info(null, path, `Association "${elemName}", published in a UNION, will be ignored`);
+          info(null, queryPath, `Association "${elemName}", published in a UNION, will be ignored`);
 
         elem._ignore = true;
       }
       else {
-        error(null, path, `Association "${elemName}" can't be published in a SAP HANA CDS UNION`);
+        error(null, queryPath, `Association "${elemName}" can't be published in a SAP HANA CDS UNION`);
       }
     }
-    else if (path.length > 4 && options.transformation === 'hdbcds') { // path.length > 4 -> is a subquery
-      error(null, path, { name: elemName },
+    else if (queryPath.length > 4 && options.transformation === 'hdbcds') { // path.length > 4 -> is a subquery
+      error(null, queryPath, { name: elemName },
             'Association $(NAME) can\'t be published in a subquery');
     }
     else {
-    /* Old implementation:
-    const isNotMixinByItself = !(elem.value && elem.value.path && elem.value.path.length == 1 && art.query && art.query.mixin && art.query.mixin[elem.value.path[0].id]);
-    */
       const isNotMixinByItself = checkIsNotMixinByItself(query, columnMap, elemName);
       const { mixinElement, mixinName } = getMixinAssocOfQueryIfPublished(query, elem, elemName);
       if (isNotMixinByItself || mixinElement !== undefined) {
-      // If the mixin is only published and not used, only display the __ clone. Kill the "original".
+        // If the mixin is only published and not used, only display the __ clone. Kill the "original".
         if (mixinElement !== undefined && !usesMixinAssociation(query, elem, elemName))
           delete query.SELECT.mixin[mixinName];
 
@@ -226,8 +275,8 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
           mixinElemName = `_${mixinElemName}`;
 
         // Copy the association element to the MIXIN clause under its alias name
-        // (shallow copy is sufficient, just fix name and value)
-        const mixinElem = Object.assign({}, elem);
+        // Needs to be a deep copy, as we transform the on-condition
+        const mixinElem = cloneCsn(elem, options);
         // Perform common transformations on the newly generated MIXIN element (won't be reached otherwise)
         transformCommon(mixinElem, mixinElemName);
 
@@ -238,30 +287,24 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
         // and fixing the association alias just created
 
         if (mixinElem.on) {
-          mixinElem.on = cloneWithTransformations(mixinElem.on, {
-            ref: (ref) => {
-            // Clone the path, without any transformations
-              const clonedPath = cloneWithTransformations(ref, {});
-              // Prepend '$projection' to the path, unless the first path step is the (mixin) element itself or starts with '$')
-              if (clonedPath[0] === elemName) {
-                clonedPath[0] = mixinElemName;
+          mixinElem.on = applyTransformationsOnNonDictionary(mixinElem, 'on', {
+            ref: (parent, prop, ref, refpath) => {
+              if (ref[0] === elemName) {
+                ref[0] = mixinElemName;
               }
-              else if (!(clonedPath[0] && clonedPath[0].startsWith('$'))) {
-                const projectionId = '$projection';
-                clonedPath.unshift(projectionId);
+              else if (!(ref[0] && ref[0].startsWith('$'))) {
+                ref.unshift('$projection');
               }
-              return clonedPath;
-            },
-            func: (func) => {
-            // Unfortunately, function names are disguised as paths, so we would prepend a '$projection'
-            // above (no way to distinguish that in the callback for 'path' above). We can only pluck it
-            // off again here ... sigh
-              if (func.ref && func.ref[0] && func.ref[0] === '$projection')
-                func.ref = func.ref.slice(1);
-
-              return func;
+              else if (ref[0] && ref[0].startsWith('$')) {
+                // TODO: I think this is non-sense. Stuff with $ is either magic or must start with $self, right?
+                const { scope } = inspectRef(refpath);
+                if (scope !== '$magic' && scope !== '$self')
+                  ref.unshift('$projection');
+              }
+              parent.ref = ref;
+              return ref;
             },
-          });
+          }, elementsPath.concat(elemName));
         }
 
         if (!mixinElem._ignore)
@@ -304,6 +347,10 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
   // eslint-disable-next-line complexity
   function transformViewOrEntity(query, artifact, artName, path) {
     const { elements } = queryOrMain(query, artifact);
+    // We use the elements from the leading query/main artifact - adapt the path
+    const elementsPath = elements === artifact.elements ? path.slice(0, 2).concat('elements') : path.concat('elements');
+    const queryPath = path;
+
     let hasNonAssocElements = false;
     const isSelect = query && query.SELECT;
     const isProjection = !!artifact.projection || query && query.SELECT && !query.SELECT.columns;
@@ -338,12 +385,12 @@ function getViewTransformer(csn, options, messageFunctions, transformCommon) {
       // (180 b) Create MIXINs for association elements in projections or views (those that are not mixins by themselves)
       // CDXCORE-585: Allow mixin associations to be used and published in parallel
       if (query !== undefined && elem.target)
-        handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, path);
+        handleAssociationElement(query, elements, columnMap, publishedMixins, elem, elemName, elementsPath, queryPath);
     }
 
     if (query && !hasNonAssocElements) {
-    // Complain if there are no elements other than unmanaged associations
-    // Allow with plain
+      // Complain if there are no elements other than unmanaged associations
+      // Allow with plain
       error(null, [ 'definitions', artName ], { $reviewed: true },
             'Expecting view or projection to have at least one element that is not an unmanaged association');
     }

package/lib/transform/forHanaNew.js

@@ -3,7 +3,7 @@
 const { setProp, isBetaEnabled } = require('../base/model');
 const { getUtils, cloneCsn, forEachGeneric,
         forEachMember,
-        forEachMemberRecursively, forEachRef,
+        forEachMemberRecursively, forEachRef, getNamespace, getResultingName,
         forAllQueries, forAllElements, hasAnnotationValue, getArtifactDatabaseNameOf,
         getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isPersistedOnDatabase, getNormalizedQuery, isAspect, walkCsnPath,
@@ -213,10 +213,6 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     }
   });
 
-  // Must happen after A2J, as A2J needs $self to correctly resolve stuff
-  if(doA2J)
-    flattening.removeLeadingSelf(csn);
-
   const {
     flattenStructuredElement,
     flattenStructStepsInRef, getForeignKeyArtifact,
@@ -232,6 +228,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     isStructured,
     addStringAnnotationTo,
     cloneWithTransformations,
+    getContextOfArtifact,
   } = getUtils(csn);
 
   // (000) Rename primitive types, make UUID a String
@@ -394,6 +391,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     removeKeyPropInType,
   ]);
 
+  // Remove leading $self to keep renderer-diffs smaller
+  if(doA2J)
+    flattening.removeLeadingSelf(csn);
+
   throwWithError();
 
   timetrace.stop();
@@ -797,14 +798,31 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         || hasAnnotationValue(artifact, '@cds.persistence.exists'))
         artifact._ignore = true;
 
+      const namingMode = options.forHana && options.forHana.names;
       // issue #3450 HANA CDS can not handle external artifacts which are part of a HANA CDS context
-      if (options.forHana.names === 'quoted' &&
-          hasAnnotationValue(artifact, '@cds.persistence.exists')) {
-        const firstPath = artifactName.split('.')[0];
-        const topParent = csn.definitions[firstPath];
-        // namespaces, contexts and services become contexts in HANA CDS
-        if (topParent && [ 'namespace', 'context', 'service' ].includes(topParent.kind))
-          warning(null, [ 'definitions', artifactName ], `"${ artifactName }": external definition belongs to ${ topParent.kind } "${ firstPath }"`);
+      if (hasAnnotationValue(artifact, '@cds.persistence.exists') &&
+          options.transformation === 'hdbcds' &&
+          (namingMode === 'quoted' || namingMode === 'hdbcds')) {
+        let hanaCDSContextName;
+        if(namingMode === 'hdbcds') {
+          // for hdbcds names we only create a context if you defined a context/service in your cdl model
+          hanaCDSContextName = getContextOfArtifact(artifactName);
+        }
+        else {
+          // for quoted naming mode, we create a context if you either defined a context/service
+          // or a namespace in your cdl model
+          hanaCDSContextName = getContextOfArtifact(artifactName) || getNamespace(csn, artifactName);
+        }
+        if (hanaCDSContextName) {
+          warning('anno-unstable-hdbcds', [ 'definitions', artifactName ],
+            {
+              id: getResultingName(csn, options.forHana.names, artifactName),
+              name: getResultingName(csn, options.forHana.names, hanaCDSContextName),
+              anno: 'cds.persistence.exists',
+            },
+            'Do not use $(ANNO) on an entity named $(ID) in SAP HANA CDS when we also create a SAP HANA CDS context named $(NAME)'
+          );
+        }
       }
     }
   }
@@ -1324,6 +1342,10 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
         if (ref[0] === assocName) // we are in the "path" from the forwarding assoc => need to remove the first part of the path
         {
           ref.shift();
+        } else if(ref && ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
+          // We could also have a $self infront of the assoc name - so we would need to shift twice
+          ref.shift();
+          ref.shift();
         }
         else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
           ref.unshift(elemName);

package/lib/transform/translateAssocsToJoins.js

@@ -1,9 +1,9 @@
 'use strict'
 
 const { setProp, forEachGeneric, forEachDefinition, isBetaEnabled } = require('../base/model');
-var { makeMessageFunction } = require('../base/messages');
+const { makeMessageFunction } = require('../base/messages');
 const { recompileX } = require('../compiler/index');
-var { linkToOrigin } = require('../compiler/utils');
+const { linkToOrigin, pathName } = require('../compiler/utils');
 const  {compactModel, compactExpr} = require('../json/to-csn');
 const { deduplicateMessages } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
@@ -309,7 +309,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       let [QA, ps] = rightMostQA(tail, head._navigation._parent.$QA || head._navigation.$QA);
       if(!QA) {
         error(null, pathNode.$location,
-          { name: pathNode.path.map(ps=ps.id).join('.') },
+          { name: pathName(pathNode.path) },
           'Please debug me: No QA found for generic path rewriting in $(NAME)')
         return;
       }

package/lib/utils/file.js

@@ -3,6 +3,7 @@
 'use strict';
 
 const fs = require('fs');
+const util = require('util');
 
 /**
  * Split the given source string into its lines.  Respects Unix,
@@ -19,8 +20,8 @@ function splitLines(src) {
  * Returns filesystem utils readFile(), isFile(), realpath() for _CDS_ usage.
  * This includes a trace as well as usage of a file cache.
  *
- * Note: The synchronous versions accept a callback as well, which is executed
- *       immediately! This is different from NodeJS's readFileSync()!
+ * Note: The synchronous versions accept a callback instead of being async (duh!), which
+ *       is executed immediately! This is different from NodeJS's readFileSync()!
  *       This is done to allow using it in places where fs.readFile (async) is used.
  *
  * @param {object} fileCache
@@ -47,10 +48,13 @@ function cdsFs(fileCache, enableTrace) {
   });
 
   return {
+    readFileAsync: util.promisify(readFile),
     readFile,
     readFileSync,
+    isFileAsync: util.promisify(isFile),
     isFile,
     isFileSync,
+    realpathAsync: util.promisify(realpath),
     realpath,
     realpathSync,
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "2.11.2",
+  "version": "2.11.4",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",

package/lib/transform/db/helpers.js

@@ -1,58 +0,0 @@
-'use strict';
-
-/**
- * If a mixin association is published, return the mixin association.
- *
- * @param {CSN.Query} query Query of the artifact to check
- * @param {object} association Association (Element) published by the view
- * @param {string} associationName
- * @returns {object} The mixin association
- */
-function getMixinAssocOfQueryIfPublished(query, association, associationName) {
-  if (query && query.SELECT && query.SELECT.mixin) {
-    const aliasedColumnsMap = Object.create(null);
-    if (query.SELECT.columns) {
-      for (const column of query.SELECT.columns) {
-        if (column.as && column.ref && column.ref.length === 1)
-          aliasedColumnsMap[column.as] = column;
-      }
-    }
-
-    for (const elem of Object.keys(query.SELECT.mixin)) {
-      const mixinElement = query.SELECT.mixin[elem];
-      let originalName = associationName;
-      if (aliasedColumnsMap[associationName])
-        originalName = aliasedColumnsMap[associationName].ref[0];
-
-      if (elem === originalName)
-        return { mixinElement, mixinName: originalName };
-    }
-  }
-  return {};
-}
-
-/**
- * Check wether the given artifact uses the given mixin association.
- *
- * @param {CSN.Query} query Query of the artifact to check
- * @param {object} association Mixin association (Element) to check for
- * @param {string} associationName
- * @returns {boolean} True if used
- */
-function usesMixinAssociation(query, association, associationName) {
-  if (query && query.SELECT && query.SELECT.columns) {
-    for (const column of query.SELECT.columns) {
-      if (typeof column === 'object' && column.ref && column.ref.length > 1 && (column.ref[0] === associationName || column.ref[0].id === associationName)) {
-        // FIXME: This is not necessarily correct: the assoc name needs not be the first component, as e.g. $projection.assoc
-        // would be also valid. Check other paths like $self.assoc ....
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-module.exports = {
-  usesMixinAssociation,
-  getMixinAssocOfQueryIfPublished,
-};