@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/transform/odata/toFinalBaseType.js

@@ -2,7 +2,7 @@
 
 const {
   forEachDefinition, forEachMemberRecursively,
-  isBuiltinType, cloneCsnDictionary,
+  isBuiltinType, cloneCsnDictionary, cloneCsn,
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
@@ -86,21 +86,95 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     // EDMX at the moment and the reference in the OData CSN is fulfilled.
     if (node.kind === 'event') return;
 
-    if (isExpandable(node, defName) || node.kind === 'type') {
-      transformers.toFinalBaseType(node);
-      if (node.type && !isBuiltinType(node.type)) {
-        // handle array of defined via a named type
-        // example in actions: 'action act() return Primitive; type Primitive: array of String;'
-        const currService = csnUtils.getServiceName(defName);
-        const finalType = csnUtils.getFinalTypeDef(node.type);
-        if (finalType.items && isBuiltinType(finalType.items.type)) {
-          if (!isArtifactInService(node.type, currService) || !isV4) {
-            node.items = finalType.items;
+    // elements have precedence over type
+    if (node.type && (!isBuiltinType(node.type) &&isExpandable(node, defName) || node.kind === 'type')) {
+      // 1. Get the final type of the node (resolve derived type chain)
+      const finalType = csnUtils.getFinalBaseType(node.type);
+      if (finalType) {
+        // The type replacement depends on whether 'node' is a definition or a member[element].
+        if (node.kind) {
+          // It is a definition and we expand to builtin type and to elements
+          // type T: S; --> Integer;
+          // type S: X; --> Integer;
+          // type X: Integer;
+          // 
+          // type A: B; -> {...}
+          // type B: C; -> { ... }
+          // type C { .... };
+          if (isBuiltinType(finalType)) {
+            // use transformUrilsNew::toFinalBaseType for the moment,
+            // as it is collects along the chain of types
+            // attributes that need to be propagated
+            // enum, length, scale, etc.
+            transformers.toFinalBaseType(node);
+            // node.type = finalType;
+          }
+          else if (csnUtils.isStructured(finalType)) {
+            cloneElements(finalType);
+          }
+          else if (node.type && node.items)
             delete node.type;
+        }
+        else {
+          // this is a member and we expand to final base only if builtin
+          //  type T: S; --> Integer;
+          //  type S: X; --> Integer;
+          //  type X: Integer;
+          //  
+          //  type {
+          //    struct_elt: many A; ---> stays the same
+          //    scalar_elt: T; ---> Integer;
+          //    type_ref_elt: type of struct_elt;
+          //  };
+          //  type A: B; -> {...}
+          //  type B: C; -> { ... }
+          //  type C { .... };
+          if (isBuiltinType(finalType)) {
+            // use transformUrilsNew::toFinalBaseType for the moment,
+            // as it is collects along the chain of types
+            // attributes that need to be propagated
+            // enum, length, scale, etc.
+            transformers.toFinalBaseType(node);
+            // node.type = finalType;
+          }
+          else if (node.type && node.type.ref) {
+            cloneElements(finalType);
           }
         }
       }
     }
+    if (node.type && !isBuiltinType(node.type)) {
+        // handle array of defined via a named type
+        // example in actions: 'action act() return Primitive; type Primitive: array of String;'
+      const currService = csnUtils.getServiceName(defName);
+      const finalType = csnUtils.getFinalTypeDef(node.type);
+      if (finalType.items && isBuiltinType(finalType.items.type)) {
+        if (!isArtifactInService(node.type, currService) || !isV4) {
+          node.items = finalType.items;
+          delete node.type;
+        }
+      }
+    }
+
+    function cloneElements(finalType) {
+      // cloneCsn only works correctly if we start "from the top"
+      let clone;
+      // do the clone only if really needed
+      if((finalType.items && !node.items) ||
+         (finalType.elements && !node.elements))
+        clone = cloneCsn({ definitions: { 'TypeDef': finalType } }, options);
+      if (finalType.items) {
+        delete node.type;
+        if(!node.items)
+          Object.assign(node, { items: clone.definitions.TypeDef.items });
+      }
+      if (finalType.elements) {
+        if(!finalType.items)
+          delete node.type;
+        if(!node.elements)
+          Object.assign(node, { elements: clone.definitions.TypeDef.elements });
+      }
+    }
   }
 
   function isExpandable(node, defName) {
@@ -119,4 +193,4 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
   }
 }
 
-module.exports = expandToFinalBaseType;
+module.exports = expandToFinalBaseType;

package/lib/transform/odata/typesExposure.js

@@ -18,7 +18,7 @@ const { copyAnnotations } = require('../../model/csnUtils');
  * @param {*} csnUtils
  * @param {object} message message object with { error } function
  */
-function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
+function typesExposure(csn, whatsMyServiceName, autoexposeSchemaName, options, csnUtils, message) {
   const { error } = message;
   // are we working with OData proxies or cross-service refs
   const isMultiSchema = options.toOdata.version === 'v4' && (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs);
@@ -30,9 +30,9 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
     // we do expose types only for definition from inside services
     const serviceName = whatsMyServiceName(defName, false);
     if (serviceName) {
-      if (['type', 'entity', 'view'].includes(def.kind)) {
+      if (def.kind === 'type' || def.kind === 'entity') {
         forEachMember(def, (element, elementName, propertyName, path) => {
-          if (['elements', 'params'].includes(propertyName)) {
+          if (propertyName === 'elements' || propertyName === 'params') {
             const artificialtName = `${isMultiSchema ?
               defNameWithoutServiceOrContextName(defName, serviceName)
               : defNameWithoutServiceOrContextName(defName, serviceName).replace(/\./g, '_')}_${elementName}`;
@@ -190,7 +190,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
       } else {
         const typeContext = csnUtils.getContextOfArtifact(typeName);
         const typeNamespace = csnUtils.getNamespaceOfArtifact(typeName);
-        const newSchemaName = `${service}.${typeContext || typeNamespace || 'root'}`;
+        const newSchemaName = `${service}.${typeContext || typeNamespace || autoexposeSchemaName}`;
         // new type name without any prefixes
         const typePlainName = typeContext ? defNameWithoutServiceOrContextName(typeName, typeContext)
           : typeName.replace(`${typeNamespace}.`, '');
@@ -209,7 +209,7 @@ function typesExposure(csn, whatsMyServiceName, options, csnUtils, message) {
      */
     function getAnonymousTypeNameInMultiSchema(typeName, parentName) {
       let currPrefix = parentName.substring(0, parentName.lastIndexOf('.'));
-      const newSchemaName = currPrefix || 'root';
+      const newSchemaName = currPrefix || autoexposeSchemaName;
       // new type name without any prefixes
       const typePlainName = defNameWithoutServiceOrContextName(typeName, newSchemaName);
 

package/lib/transform/odata/utils.js

@@ -18,7 +18,7 @@ function isAssociationOrComposition(artifact) {
   return isAssociation(artifact) || isComposition(artifact);
 }
 
-function isManagedAssociationElement(artifact) {
+function isManagedAssociation(artifact) {
   return artifact.target !== undefined && artifact.on === undefined;
 }
 
@@ -94,5 +94,5 @@ module.exports = {
   isArtifactInSomeService,
   isAssociationOrComposition,
   isLocalizedArtifactInService,
-  isManagedAssociationElement,
+  isManagedAssociation,
 }

package/lib/transform/transformUtilsNew.js

@@ -10,11 +10,12 @@ const { csnRefs } = require('../model/csnRefs');
 
 const { copyAnnotations, applyTransformations } = 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);
@@ -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];
         }
@@ -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;
     }
@@ -389,7 +400,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    *
    * @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) {
@@ -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 cloneTypeDef = cloneCsn(typeDef, options);
-      // With hdbcds-hdbcds, don't resolve structured types - but propagrate ".items", to turn into LargeString later on.
+      // 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: cloneTypeDef.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: cloneTypeDef.elements});
+        if(!node.elements)
+          Object.assign(node, {elements: cloneTypeDef.elements});
       }
 
 
@@ -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] = {
@@ -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

@@ -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);
@@ -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 {
@@ -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,
+};