@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/transform/transformUtilsNew.js

@@ -9,12 +9,13 @@ const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
 
 const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
-const { cloneCsn, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { cloneCsn, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { ModelError } = require("../base/error");
 
 // Return the public functions of this module, with 'model' captured in a closure (for definitions, options etc).
 // Use 'pathDelimiter' for flattened names (e.g. of struct elements or foreign key elements).
 // 'model' is compacted new style CSN
-// TODO: Error and warnings handling with compacted CSN? - currently just throw new Error for everything
+// TODO: Error and warnings handling with compacted CSN? - currently just throw new ModelError for everything
 // TODO: check the situation with assocs with values. In compacted CSN such elements have only "@Core.Computed": true
 function getTransformers(model, options, pathDelimiter = '_') {
   const { error, warning, info } = makeMessageFunction(model, options);
@@ -108,7 +109,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // 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 (const prop of ['type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type']) {
-      if (fkArtifact[prop] != undefined) {
+      if (fkArtifact[prop] !== undefined) {
         foreignKeyElement[prop] = fkArtifact[prop];
       }
     }
@@ -118,7 +119,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
     // If the association is non-fkArtifact resp. key, so should be the foreign key field
     for (const prop of ['notNull', 'key']) {
-      if (assoc[prop] != undefined) {
+      if (assoc[prop] !== undefined) {
         foreignKeyElement[prop] = assoc[prop];
       }
     }
@@ -246,6 +247,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
     const struct = elemType ? elemType.elements : elem.elements;
 
     // Collect all child elements (recursively) into 'result'
+    // TODO: Do not report collisions in the generated elements here, but instead
+    // leave that work to the receiver of this result
     let result = Object.create(null);
     const addGeneratedFlattenedElement = (e, eName) => {
       if(result[eName]){
@@ -286,7 +289,11 @@ function getTransformers(model, options, pathDelimiter = '_') {
       // Copy annotations from struct (not overwriting, because deep annotations should have precedence)
       copyAnnotations(elem, flatElem, false);
       // Copy selected type properties
-      for (let p of ['key', 'virtual', 'masked', 'viaAll']) {
+      const props = ['key', 'virtual', 'masked', 'viaAll'];
+      // 'localized' is needed for OData
+      if(options.toOdata)
+        props.push('localized');
+      for (let p of props) {
         if (elem[p]) {
           flatElem[p] = elem[p];
         }
@@ -302,7 +309,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    *  [ (Entity), (struct1), (struct2), (assoc), (elem) ] should result in
    *  [ (Entity), (struct1_struct2_assoc), (elem) ]
    *
-   * @param {string[]} ref 
+   * @param {string[]} ref
    * @param {CSN.Path} path CSN path to the ref
    * @param {object[]} [links] Pre-resolved links for the given ref - if not provided, will be calculated JIT
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
@@ -313,12 +320,14 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2) {
       return ref;
+    } else if(scope === '$self' && ref.length === 2) {
+      return ref;
     }
 
     return flatten(ref, path);
 
     function flatten(ref, path) {
-      let result = [];
+      let result = scope === '$self' ? [ref[0]] : [];
       //let stack = []; // IDs of path steps not yet processed or part of a struct traversal
       if(!links && !scope) { // calculate JIT if not supplied
         const res = inspectRef(path);
@@ -327,23 +336,25 @@ function getTransformers(model, options, pathDelimiter = '_') {
       }
       if (scope === '$magic')
         return ref;
+      // Don't process a leading $self - it will a .art with .elements!
+      const startIndex = scope === '$self' ? 1 : 0;
       let flattenStep = false;
-      links.forEach((value, idx) => {
+      for(let i = startIndex; i < links.length; i++) {
+        const value = links[i];
         if (flattenStep) {
-          result[result.length - 1] += pathDelimiter + (ref[idx].id ? ref[idx].id : ref[idx]);
+          result[result.length - 1] += pathDelimiter + (ref[i].id ? ref[i].id : ref[i]);
           // if we had a filter or args, we had an assoc so this step is done
           // we then keep along the filter/args by updating the id of the current ref
-          if(ref[idx].id) {
-            ref[idx].id = result[result.length-1];
-            result[result.length-1] = ref[idx];
+          if(ref[i].id) {
+            ref[i].id = result[result.length-1];
+            result[result.length-1] = ref[i];
           }
         }
         else {
-          result.push(ref[idx]);
+          result.push(ref[i]);
         }
-
         flattenStep = value.art && !value.art.kind && !value.art.SELECT && !value.art.from && (value.art.elements || effectiveType(value.art).elements || (resolvedLinkTypes.get(value)||{}).elements);
-      });
+      }
 
       return result;
     }
@@ -351,7 +362,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
   /**
    * Copy properties of the referenced type, but don't resolve to the final base type.
-   * 
+   *
    * Do not copy the length if it was just set via the default-value.
    *
    * @param {any} node Node to copy to
@@ -387,9 +398,9 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * also unravel derived enum types, i.e. take the final base type of the enum's base type.
    * Similar with associations and compositions (we probably need a _baseType link)
    *
-   * @param {CSN.Artifact} node 
+   * @param {CSN.Artifact} node
    * @param {WeakMap} [resolved] WeakMap containing already resolved refs
-   * @param {boolean} [keepLocalized=false] Wether to clone .localized from a type def
+   * @param {boolean} [keepLocalized=false] Whether to clone .localized from a type def
    * @returns {void}
    */
   function toFinalBaseType(node, resolved, keepLocalized=false) {
@@ -406,7 +417,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
         delete node.type; // delete the type reference as edm processing does not expect it
       } else if(finalBaseType.items) {
           // This changes the order - to be discussed!
-        node.items = cloneCsn(finalBaseType, options).items; // copy items
+        node.items = cloneCsn(finalBaseType.items, options); // copy items
         delete node.type;
       } else {
         node.type=finalBaseType;
@@ -420,20 +431,23 @@ function getTransformers(model, options, pathDelimiter = '_') {
     let typeDef = typeof node.type === 'string' ? getCsnDef(node.type) : node.type;
     // Nothing to do if type is an array or a struct type
     if (typeDef.items || typeDef.elements) {
+      // Expand structured types on entity elements for flat OData
       if(!(options.transformation === 'hdbcds' || options.toSql))
         return;
 
       // cloneCsn only works correctly if we start "from the top"
-      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options);
-      // With hdbcds-hdbcds, don't resolve structured types - but propagrate ".items", to turn into LargeString later on.
+      const cloneTypeDef = cloneCsn(typeDef, options);
+      // With hdbcds-hdbcds, don't resolve structured types - but propagate ".items", to turn into LargeString later on.
       if(typeDef.items) {
         delete node.type;
-        Object.assign(node, {items: clone.definitions.TypeDef.items});
+        if(!node.items)
+          Object.assign(node, {items: cloneTypeDef.items});
       }
       if(typeDef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
         if(!typeDef.items)
           delete node.type;
-        Object.assign(node, {elements: clone.definitions.TypeDef.elements});
+        if(!node.elements)
+          Object.assign(node, {elements: cloneTypeDef.elements});
       }
 
 
@@ -441,7 +455,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     }
     // if the declared element is an enum, these values are with priority
     if (!node.enum && typeDef.enum) {
-      const clone = cloneCsn({definitions: {'TypeDef': typeDef }}, options).definitions.TypeDef.enum;
+      const clone = cloneCsnDictionary(typeDef.enum, options);
       Object.assign(node, { enum: clone });
     }
     if (node.length === undefined && typeDef.length !== undefined)
@@ -593,7 +607,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   //                 elemName         typeName        isKey               defaultVal       notNull
   function createScalarElement(elemName, typeName, isKey = false, defaultVal = undefined, notNull=false) {
     if (!isBuiltinType(typeName) && !model.definitions[typeName]) {
-      throw new Error('Expecting valid type name: ' + typeName);
+      throw new ModelError('Expecting valid type name: ' + typeName);
     }
     let result = {
       [elemName]: {
@@ -684,7 +698,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function addForeignKey(foreignKey, elem) {
     // Sanity checks
     if (!elem.target || !elem.keys) {
-      throw new Error('Expecting managed association element with foreign keys');
+      throw new ModelError('Expecting managed association element with foreign keys');
     }
 
     // Add the foreign key
@@ -703,7 +717,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function addElement(elem, artifact, artifactName) {
     // Sanity check
     if (!artifact.elements) {
-      throw new Error('Expecting artifact with elements: ' + JSON.stringify(artifact));
+      throw new ModelError('Expecting artifact with elements: ' + JSON.stringify(artifact));
     }
     let elemName = Object.keys(elem)[0];
     // Element must not exist
@@ -734,7 +748,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    */
   function copyAndAddElement(elem, artifact, artifactName, elementName) {
     if (!artifact.elements) {
-      throw new Error('Expected structured artifact');
+      throw new ModelError('Expected structured artifact');
     }
     // Must not already have such an element
     if (artifact.elements[elementName]) {
@@ -765,14 +779,14 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
     if (returnTypeName) {
       if (!isBuiltinType(returnTypeName) && !model.definitions[returnTypeName])
-        throw new Error('Expecting valid return type name: ' + returnTypeName);
+        throw new ModelError('Expecting valid return type name: ' + returnTypeName);
       action.returns = { type: returnTypeName };
     }
 
     // Add parameter if provided
     if (paramName && paramTypeName) {
       if (!isBuiltinType(paramTypeName) && !model.definitions[paramTypeName])
-        throw new Error('Expecting valid parameter type name: ' + paramTypeName);
+        throw new ModelError('Expecting valid parameter type name: ' + paramTypeName);
 
       action.params = Object.create(null);
       action.params[paramName] = {
@@ -865,7 +879,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function checkMultipleAssignments(array, annoName, artifact, artifactName, err = true) {
     if (array.length > 1) {
       const loc = ['definitions', artifactName];
-      if (err == true) {
+      if (err === true) {
         error(null, loc, { anno: annoName }, `Annotation $(ANNO) must be assigned only once`);
       } else {
         warning(null, loc, { anno: annoName },`Annotation $(ANNO) must be assigned only once`);
@@ -1084,7 +1098,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    * Expand structured expression arguments to flat reference paths.
    * Structured elements are real sub element lists and managed associations.
    * All unmanaged association definitions are rewritten if applicable (elements/mixins).
-   * Also, HAVING and WHERE clauses are rewritten. We also check for infix filters and 
+   * Also, HAVING and WHERE clauses are rewritten. We also check for infix filters and
    * .xpr in columns.
    *
    * @todo Check if can be skipped for abstract entity  and or cds.persistence.skip ?
@@ -1105,7 +1119,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       'xpr': (parent, name, xpr, path) => {
         parent.xpr = expand(parent.xpr, path.concat(name));
       }
-    }, undefined, undefined, options);
+    }, [], options);
 
     /*
       flatten structured leaf types and return array of paths

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');
@@ -120,7 +120,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     /*
       Setup QAs for mixins
       Mark all mixin assoc definitions with a pseudo QA that points to the assoc target.
-      This QA is required to detect mixin assoc usages to decide wether a minimum or full
+      This QA is required to detect mixin assoc usages to decide whether a minimum or full
       join needs to be done
     */
     forEachQuery(createQAForMixinAssoc, env);
@@ -309,13 +309,13 @@ 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;
       }
       // if the found QA is the mixin QA and if the path length is one,
       // this indicates the publishing of a mixin assoc, don't rewrite the path
-      if(QA.mixin && tail.length == 1)
+      if(QA.mixin && tail.length === 1)
         return;
       let pos = tail.indexOf(ps);
       // cut off ps if it's a join relevant association with postfix
@@ -670,7 +670,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             if(fwdAssoc)
             {
               //env.assocStack.includes(fwdAssoc) => recursion
-              if(env.assocStack.length == 2) {
+              if(env.assocStack.length === 2) {
                 // reuse (ugly) error message from forHana
                 error(null, env.assocStack[0].location,
                   { name: '$self', id: '$self' },
@@ -702,7 +702,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         // ON cond of the forward assoc with swapped src/tgt aliases
         let fwdAssoc = getForwardAssociationExpr(expr);
         if(fwdAssoc) {
-          if(env.assocStack.length == 2) {
+          if(env.assocStack.length === 2) {
             // reuse (ugly) error message from forHana
             error(null, expr.location, 'An association that uses “$self” in its ON-condition can\'t be compared to “$self”');
             // don't check these paths again
@@ -736,7 +736,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         let newSrcAlias = tgtAlias;
         let newTgtAlias = {};
         // first try to identify table alias for complex views or redirected associations
-        if(fwdAssoc._redirected && fwdAssoc._redirected.length && 
+        if(fwdAssoc._redirected && fwdAssoc._redirected.length &&
            // redirected target must have a $QA
            fwdAssoc._redirected[fwdAssoc._redirected.length-1].$QA &&
            // $QA's artifact must either be same srcAlias artifact
@@ -793,25 +793,8 @@ function translateAssocsToJoins(model, inputOptions = {})
                 If the value is an expression in the select block, return the unmodified
                 expression. rewriteGenericPaths will check and rewrite these paths later
                 to the correct ON condition expression.
-
-                Hack alert:
-                But if this mixin ON condition path starts with $self no foreign key can
-                be generated, raise the error here and set $check to false
-                as it is too hard for checkPathDictionary() to find out that this is a
-                mixin speciality. Use same mesage as in checkPathDictionary().
               */
 
-              path.forEach(ps => { // eslint-disable-line consistent-return
-                if(ps._artifact.target) {
-                  error(null, pathNode.location,
-                    { name: env.lead.name.absolute,  id: ps.id, alias: pathAsStr(pathNode.path) },
-                    '$(NAME): $(ID) in path $(ALIAS) must not be an association'
-                  );
-                  //pathNode.$check = false;
-                  return pathNode;
-                }
-              });
-
               if(!value.path)
                 return value;
               else {
@@ -912,7 +895,7 @@ function translateAssocsToJoins(model, inputOptions = {})
               combined list of elements made available by the from clause.
           */
           let _navigation = undefined; // don't modify original path
-          if(env.assocStack.length == 2) {
+          if(env.assocStack.length === 2) {
             // a mixin assoc cannot have a structure prefix, it's sufficient to check head
             if(head.id === env.assocStack.id()) {
               // source side from view point of view (target side from forward point of view)
@@ -974,7 +957,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
       // Return the original association if expr is a backlink term, undefined otherwise
       function getForwardAssociationExpr(expr) {
-        if(expr.op && expr.op.val === '=' && expr.args.length == 2) {
+        if(expr.op && expr.op.val === '=' && expr.args.length === 2) {
           return getForwardAssociation(expr.args[0].path, expr.args[1].path);
         }
         return undefined;
@@ -983,10 +966,10 @@ function translateAssocsToJoins(model, inputOptions = {})
       function getForwardAssociation(lhs, rhs) {
         // [alpha.]BACKLINK.[beta.]FORWARD
         if(lhs && rhs) {
-          if(rhs.length == 1 && rhs[0].id === '$self' &&
+          if(rhs.length === 1 && rhs[0].id === '$self' &&
               lhs.length > 1 && hasPrefix(lhs))
             return lhs[lhs.length-1]._artifact;
-          if(lhs.length == 1 && lhs[0].id === '$self' &&
+          if(lhs.length === 1 && lhs[0].id === '$self' &&
               rhs.length > 1 && hasPrefix(rhs))
             return rhs[rhs.length-1]._artifact;
         }
@@ -1090,7 +1073,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
   /*
     Replace the table alias node in $tableAliases inplace with the newly created JOIN node
-    See definer.js initTableExpression for details where _joinParent and $joinArgsIndex is set.
+    See define.js initTableExpression for details where _joinParent and $joinArgsIndex is set.
   */
   function replaceTableAliasInPlace( tableAlias, replacementNode ) {
     if (tableAlias._joinParent)

package/lib/transform/universalCsn/.eslintrc.json

@@ -0,0 +1,36 @@
+{
+  "root": true,
+  "plugins": ["sonarjs", "jsdoc"],
+  "extends": ["../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended", "plugin:jsdoc/recommended"],
+  "rules": {
+    "prefer-const": "error",
+    "quotes": ["error", "single", "avoid-escape"],
+    "prefer-template": "error",
+    "no-trailing-spaces": "error",
+    "template-curly-spacing":["error", "never"],
+    "complexity": ["warn", 30],
+    "max-len": "off",
+    // Don't enforce stupid descriptions
+    "jsdoc/require-param-description": "off",
+    "jsdoc/require-returns-description": "off",
+    // Very whiny and nitpicky
+    "sonarjs/cognitive-complexity": "off",
+    // Does not recognize TS types
+    "jsdoc/no-undefined-types": "off",
+    // Just annoying as hell
+    "sonarjs/no-duplicate-string": "off"
+  },
+  "parserOptions": {
+    "ecmaVersion": 2018,
+    "sourceType": "script"
+  },
+  "env": {
+    "es6": true,
+    "node": true
+  },
+  "settings": {
+    "jsdoc": {
+      "mode": "typescript"
+    }
+  }
+}

package/lib/transform/universalCsn/coreComputed.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const {
+  getUtils, forEachDefinition, forAllQueries, getNormalizedQuery,
+} = require('../../model/csnUtils');
+const { setAnnotationIfNotDefined } = require('./utils');
+
+/**
+ * Set @Core.Computed on the elements of views (and projections).
+ *
+ * @param {CSN.Model} csn
+ */
+function setCoreComputedOnViews(csn) {
+  const {
+    artifactRef, getColumn, getElement,
+  } = getUtils(csn, 'init-all');
+
+  forEachDefinition(csn, (artifact) => {
+    if (artifact.query || artifact.projection) {
+      forAllQueries(getNormalizedQuery(artifact).query, (query) => {
+        if (query.SELECT)
+          traverseQueryAndAttachCoreComputed(query, query.SELECT.elements || artifact.elements);
+      });
+    }
+  });
+  /**
+   * Attach @Core.Computed to elements resulting from calculated fields
+   *
+   * To do that, for a given element, we search for its matching column/subquery-element (its ancestor).
+   * At the ancestor, we can see if it needs a @CoreComputed - check out {@link needsCoreComputed} for details.
+   *
+   *
+   * @param {CSN.Query} query
+   * @param {CSN.Elements} elements
+   */
+  function traverseQueryAndAttachCoreComputed(query, elements) {
+    for (const [ name, element ] of Object.entries(elements)) {
+      const ancestor = getAncestor(element, name, query.SELECT);
+
+      if (needsCoreComputed(ancestor)) // calculated field, function or virtual
+        setAnnotationIfNotDefined(element, '@Core.Computed', true);
+      if (ancestor && (ancestor.expand || ancestor.inline))
+        traverseExpandInline(ancestor, attachCoreComputed);
+    }
+
+    /**
+     * Get the ancestor of a given element - either a direct column that "caused" it, or an element
+     * from some other artifact (table or view/subquery). The later happens via SELECT * and can be found by drilling down into the
+     * FROM-clause.
+     *
+     * @param {CSN.Element} element
+     * @param {string} name
+     * @param {CSN.QuerySelect} base
+     * @returns {CSN.Column|CSN.Element}
+     */
+    function getAncestor(element, name, base) {
+      const column = getColumn(element);
+      if (column)
+        return column;
+      return getElementFromFrom(name, base.from);
+    }
+
+    /**
+     * Get the element <name> from the given query-base (from of a select).
+     *
+     * For a simple ref to a table, resolve the ref and check the elements
+     * For a UNION, drill down into the leading query
+     * For a JOIN, check each join-argument
+     * For a query with subelements, check the subelements
+     *
+     * @param {string} name
+     * @param {object} base
+     * @returns {CSN.Element}
+     * @todo cleanup throw(s) - but leave in during dev
+     */
+    function getElementFromFrom(name, base) {
+      if (base.SELECT && base.SELECT.elements) {
+        return getAncestor(base.SELECT.elements[name], name, base.SELECT);
+      }
+      else if (base.ref) {
+        let artifact = artifactRef(base);
+        if (artifact.target)
+          artifact = artifactRef(artifact.target);
+        return artifact.elements[name];
+      }
+      else if (base.SET) {
+        return getElementFromFrom(name, base.SET.args[0]);
+      }
+      else if (base.args && base.join) {
+        const result = checkJoinSources(base.args, name);
+        if (!result)
+          throw new Error(`Could not find ${name} in ${JSON.stringify(base.args)}`);
+        return result;
+      }
+
+      throw new Error(JSON.stringify(base));
+    }
+
+    /**
+     * For the given JOIN-args, check if one of the join sources provides an element <name>
+     *
+     * @param {Array} args
+     * @param {string} name
+     * @returns {CSN.Element|null} Null if no element was found
+     */
+    function checkJoinSources(args, name) {
+      for (const arg of args) {
+        if (arg.args) { // Join after join - A join B on <..> join C on <..>
+          const result = checkJoinSources(arg.args, name);
+          if (result)
+            return result;
+        }
+        else { // All other cases - normal ref, a subselect, etc. pp
+          const result = getElementFromFrom(name, arg);
+          if (result)
+            return result;
+        }
+      }
+
+      return null;
+    }
+
+    /**
+     * On a given column, attach @Core.Computed if needed
+     *
+     * @param {CSN.Column} column
+     */
+    function attachCoreComputed(column) {
+      if (needsCoreComputed(column))
+        setAnnotationIfNotDefined(getElement(column), '@Core.Computed', true);
+    }
+
+    /**
+     * Return whether the given columns element needs to be marked with @Core.Computed.
+     *
+     * @param {CSN.Column} column
+     * @returns {boolean}
+     */
+    function needsCoreComputed(column) {
+      return column && ( column.xpr || column.func || column.val !== undefined || column.param || column.SELECT || column.SET || column.ref && column.ref[0] in {
+        $at: 1, $now: 1, $user: 1, $session: 1,
+      });
+    }
+
+    /**
+     * Call the given callback for all sub-things of a .expand/.inline and drill further down into other .expand/.inline
+     *
+     * @param {CSN.Column} column
+     * @param {Function} callback
+     */
+    function traverseExpandInline(column, callback) {
+      if (column.expand) {
+        column.expand.forEach((col) => {
+          callback(col);
+          traverseExpandInline(col, callback);
+        });
+      }
+      else if (column.inline) {
+        column.inline.forEach((col) => {
+          callback(col);
+          traverseExpandInline(col, callback);
+        });
+      }
+    }
+  }
+}
+
+module.exports = {
+  setCoreComputedOnViews,
+};