@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/render/utils/sql.js

@@ -18,7 +18,7 @@ const { ModelError } = require('../../base/error');
  *
  * @returns {string} SQL statement which can be used to create the referential constraint on the db.
  */
-function renderReferentialConstraint(constraint, indent, toUpperCase, csn, options, alterConstraint = false) {
+function renderReferentialConstraint( constraint, indent, toUpperCase, csn, options, alterConstraint = false ) {
   let quoteId;
   // for to.hana we can't utilize the sql identifier utils
   if (options.transformation === 'hdbcds') {
@@ -29,7 +29,7 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     };
   }
   else {
-    quoteId = getIdentifierUtils(options).quoteSqlId;
+    quoteId = getIdentifierUtils(csn, options).quoteSqlId;
   }
   if (toUpperCase) {
     constraint.identifier = constraint.identifier.toUpperCase();
@@ -81,8 +81,8 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
  * @param {CSN.Options} options
  * @returns quoteSqlId and prepareIdentifier function
  */
-function getIdentifierUtils(options) {
-  return { quoteSqlId, prepareIdentifier };
+function getIdentifierUtils( csn, options ) {
+  return { quoteSqlId, prepareIdentifier, renderArtifactName };
   /**
    * Return 'name' with appropriate "-quotes.
    * Additionally perform the following conversions on 'name'
@@ -95,7 +95,7 @@ function getIdentifierUtils(options) {
    * @param {string} name Identifier to quote
    * @returns {string} Quoted identifier
    */
-  function quoteSqlId(name) {
+  function quoteSqlId( name ) {
     name = prepareIdentifier(name);
 
     switch (options.sqlMapping) {
@@ -120,7 +120,7 @@ function getIdentifierUtils(options) {
      * @param {string} name Identifier to prepare
      * @returns {string} Identifier prepared for quoting
      */
-  function prepareIdentifier(name) {
+  function prepareIdentifier( name ) {
     // Sanity check
     if (options.sqlDialect === 'sqlite' && options.sqlMapping !== 'plain')
       throw new ModelError(`Not expecting ${options.sqlMapping} names for 'sqlite' dialect`);
@@ -137,6 +137,22 @@ function getIdentifierUtils(options) {
         throw new ModelError(`No matching rendering found for naming mode ${options.sqlMapping}`);
     }
   }
+
+  /**
+   * Given the following artifact name: namespace.prefix.entity.with.dot, render the following,
+   * depending on the naming mode:
+   * - plain: NAMESPACE_PREFIX_ENTITY_WITH_DOT
+   * - quoted: namespace.prefix.entity_with_dot
+   * - hdbcds: namespace::prefix.entity_with_dot
+   *
+   *
+   * @param {string} artifactName Artifact name to render
+   *
+   * @returns {string} Artifact name
+   */
+  function renderArtifactName( artifactName ) {
+    return quoteSqlId(getResultingName(csn, options.sqlMapping, artifactName));
+  }
 }
 
 

package/lib/render/utils/stringEscapes.js

@@ -16,7 +16,7 @@ const unpairedSurrogate = /[^\u{D800}-\u{DBFF}][\u{DC00}-\u{DFFF}]|[\u{D800}-\u{
  * @param {string} str
  * @return {boolean}
  */
-function hasUnpairedUnicodeSurrogate(str) {
+function hasUnpairedUnicodeSurrogate( str ) {
   return unpairedSurrogate.test(str);
 }
 
@@ -26,7 +26,7 @@ function hasUnpairedUnicodeSurrogate(str) {
  * @param {string} str
  * @return {boolean}
  */
-function hasControlCharacters(str) {
+function hasControlCharacters( str ) {
   return controlCharacters.test(str);
 }
 
@@ -60,7 +60,7 @@ function hasControlCharacters(str) {
  * @param {object} escapes
  * @returns {string}
  */
-function escapeString(str, escapes) {
+function escapeString( str, escapes ) {
   const output = [];
 
   for (let i = 0; i < str.length; ++i) {

package/lib/transform/db/applyTransformations.js

@@ -22,7 +22,7 @@ const { setProp } = require('../../base/model');
  * @param {CSN.Path} path Path to parent
  * @returns {object} parent with transformations applied
  */
-function applyTransformationsInternal(parent, prop, customTransformers, artifactTransformers, options, path = []) {
+function applyTransformationsInternal( parent, prop, customTransformers, artifactTransformers, options, path = [] ) {
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -196,7 +196,7 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
  * @param {CSN.Path} path Path pointing to parent
  * @returns {object} parent[prop] with transformations applied
  */
-function applyTransformationsOnNonDictionary(parent, prop, customTransformers = {}, options = {}, path = []) {
+function applyTransformationsOnNonDictionary( parent, prop, customTransformers = {}, options = {}, path = [] ) {
   return applyTransformationsInternal(parent, prop, customTransformers, [], options, path)[prop];
 }
 
@@ -217,7 +217,7 @@ function applyTransformationsOnNonDictionary(parent, prop, customTransformers =
  * @param {CSN.Path} path Path pointing to parent
  * @returns {object} dictionary with transformations applied
  */
-function applyTransformationsOnDictionary(dictionary, customTransformers = {}, options = {}, path = []) {
+function applyTransformationsOnDictionary( dictionary, customTransformers = {}, options = {}, path = [] ) {
   return applyTransformationsInternal(dictionary, null, customTransformers, [], { directDict: true, ...options }, path);
 }
 

package/lib/transform/db/assertUnique.js

@@ -20,7 +20,7 @@ const { pathName } = require('../../compiler/utils');
  * @param {Function} error Message function for errors
  * @param {Function} info Message function for info
  */
-function processAssertUnique(csn, options, error, info) {
+function processAssertUnique( csn, options, error, info ) {
   const { resolvePath, flattenPath } = getTransformers(csn, options);
 
   forEachDefinition(csn, handleAssertUnique);
@@ -30,7 +30,7 @@ function processAssertUnique(csn, options, error, info) {
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
-  function handleAssertUnique(artifact, artifactName) {
+  function handleAssertUnique( artifact, artifactName ) {
     // operate only on real entities that are not abstract
     if (artifact.abstract || (artifact.kind !== 'entity' || (artifact.query || artifact.projection) && !hasAnnotationValue(artifact, '@cds.persistence.table')))
       return;
@@ -38,12 +38,13 @@ function processAssertUnique(csn, options, error, info) {
     const constraintDict = Object.create(null);
     // filter unique constraints from annotations
     for (const propName in artifact) {
-      if (propName.startsWith('@assert.unique') && artifact[propName] !== null) {
-        const anno = propName;
+      const anno = propName;
+      if (propName === '@assert.unique')
+        error(null, [ 'definitions', artifactName ], { anno }, '$(ANNO): Table constraint can\'t be anonymous');
+
+      if (propName.startsWith('@assert.unique.') && artifact[propName] !== null) {
         // Constraint Name check
         const constraintName = propName.split('.').splice(2);
-        if (constraintName.length === 0)
-          error(null, [ 'definitions', artifactName ], { anno }, '$(ANNO): Table constraint can\'t be anonymous');
         if (constraintName.length > 1)
         // Neither HANA CDS nor HANA SQL allow dots in index names
           error(null, [ 'definitions', artifactName ], { anno }, '$(ANNO): Illegal character \'.\' in constraint name');
@@ -121,7 +122,7 @@ function processAssertUnique(csn, options, error, info) {
      * @param {string} propName
      * @returns {Array} Array of paths
      */
-    function checkVal(val, propName) {
+    function checkVal( val, propName ) {
       const paths = [];
       const loc = [ 'definitions', artifactName ];
       if (!Array.isArray(val)) {
@@ -147,7 +148,7 @@ function processAssertUnique(csn, options, error, info) {
        * @param {any} v
        * @returns {string|string[]|any}
        */
-      function unref(v) {
+      function unref( v ) {
         if (Array.isArray(v))
           return v.map(unref);
         return (v['='] || v);
@@ -160,7 +161,7 @@ function processAssertUnique(csn, options, error, info) {
      * @param {string} val
      * @returns {object}
      */
-    function toRef(val) {
+    function toRef( val ) {
       let ref = val.split('.');
       const [ head, ...tail ] = ref;
       if (head === '$self' || head === '$projection')
@@ -185,7 +186,7 @@ function processAssertUnique(csn, options, error, info) {
      * @param {object} path
      * @param {string} constraintName
      */
-    function check(path, constraintName) {
+    function check( path, constraintName ) {
       if (path.isChecked)
         return;
       path.isChecked = true;
@@ -262,12 +263,12 @@ function processAssertUnique(csn, options, error, info) {
  * @param {CSN.Options} options
  * @param {string} pathDelimiter
  */
-function rewriteUniqueConstraints(csn, options, pathDelimiter) {
+function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
   forEachDefinition(csn, rewrite);
   /**
    * @param {CSN.Artifact} artifact
    */
-  function rewrite(artifact) {
+  function rewrite( artifact ) {
     if (artifact.$tableConstraints && artifact.$tableConstraints.unique) {
       const uniqueConstraints = artifact.$tableConstraints.unique;
       // it's safe to add the tc here

package/lib/transform/db/associations.js

@@ -15,7 +15,7 @@ const {
  * @param {string} pathDelimiter
  * @returns {CSN.Model} Return the input csn, with the transformations applied
  */
-function attachOnConditions(csn, pathDelimiter) {
+function attachOnConditions( csn, pathDelimiter ) {
   const {
     isManagedAssociation,
   } = getUtils(csn);
@@ -41,7 +41,7 @@ function attachOnConditions(csn, pathDelimiter) {
    * @param {string} elemName
    * @returns {void}
    */
-  function transformManagedAssociation(elem, elemName) {
+  function transformManagedAssociation( elem, elemName ) {
     // No need to run over this - we already did, possibly because it was referenced in the ON-Condition
     // of another association - see a few lines lower
     if (alreadyHandled.has(elem))
@@ -107,7 +107,7 @@ function attachOnConditions(csn, pathDelimiter) {
  * @param {string} pathDelimiter
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
  */
-function getFKAccessFinalizer(csn, pathDelimiter) {
+function getFKAccessFinalizer( csn, pathDelimiter ) {
   const {
     inspectRef,
   } = getUtils(csn);
@@ -123,7 +123,7 @@ function getFKAccessFinalizer(csn, pathDelimiter) {
    * @param {CSN.Artifact} artifact Artifact to check
    * @param {string} artifactName Name of the artifact
    */
-  function handleManagedAssocSteps(artifact, artifactName) {
+  function handleManagedAssocSteps( artifact, artifactName ) {
     const transformer = {
       ref: (refOwner, prop, ref, path) => {
         // [<assoc base>.]<managed assoc>.<field>
@@ -177,7 +177,7 @@ function getFKAccessFinalizer(csn, pathDelimiter) {
      * @param {number} startIndex
      * @returns {object | undefined} CSN definition of the source of the managed association
      */
-    function findSource(links, startIndex) {
+    function findSource( links, startIndex ) {
       for (let i = startIndex; i >= 0; i--) {
         const link = links[i];
         // We found the latest assoc step - now check where that points to

package/lib/transform/db/cdsPersistence.js

@@ -19,7 +19,7 @@ function getAnnoProcessor() {
   /**
    * @param {CSN.Artifact} artifact
    */
-  function handleCdsPersistence(artifact) {
+  function handleCdsPersistence( artifact ) {
     const ignoreArtifact = (artifact.kind === 'entity') &&
                            (artifact.abstract ||
                             hasAnnotationValue(artifact, '@cds.persistence.skip') ||
@@ -39,7 +39,7 @@ function getAnnoProcessor() {
  * @param {Function} messageFunctions.info
  * @returns {(artifact: CSN.Artifact, artifactName: string, prop: string, path: CSN.Path) => void} Callback function for forEachDefinition
  */
-function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
+function getAssocToSkippedIgnorer( csn, options, messageFunctions ) {
   const { info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
 
@@ -55,7 +55,7 @@ function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
    * @param {string} prop
    * @param {CSN.Path} path
    */
-  function ignoreAssociationToSkippedTarget(artifact, artifactName, prop, path) {
+  function ignoreAssociationToSkippedTarget( artifact, artifactName, prop, path ) {
     if (isPersistedOnDatabase(artifact)) {
       // TODO: structure in CSN is artifact.query.[SELECT/SET].mixin
       if (artifact.query) {
@@ -79,7 +79,7 @@ function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
    * @param {string} prop
    * @param {CSN.Path} path
    */
-  function ignore(member, memberName, prop, path) {
+  function ignore( member, memberName, prop, path ) {
     if (options.sqlDialect === 'hana' &&
        !member._ignore && member.target &&
        isAssocOrComposition(member.type) &&
@@ -102,7 +102,7 @@ function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
  * @param {Function} messageFunctions.error
  * @returns {(artifact: CSN.Artifact, artifactName) => void} Callback function for forEachDefinition
  */
-function getPersistenceTableProcessor(csn, options, messageFunctions ) {
+function getPersistenceTableProcessor( csn, options, messageFunctions ) {
   const { error } = messageFunctions;
   const {
     recurseElements,
@@ -115,7 +115,7 @@ function getPersistenceTableProcessor(csn, options, messageFunctions ) {
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
-  function handleQueryish(artifact, artifactName) {
+  function handleQueryish( artifact, artifactName ) {
     const stripQueryish = artifact.query && hasAnnotationValue(artifact, '@cds.persistence.table');
 
     if (stripQueryish) {
@@ -124,8 +124,10 @@ function getPersistenceTableProcessor(csn, options, messageFunctions ) {
 
       recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
         // All elements must have a type for this to work
-        if (!member._ignore && !member.kind && !member.type)
-          error(null, path, 'Expecting element to have a type if view is annotated with “@cds.persistence.table“');
+        if (!member._ignore && !member.kind && !member.type) {
+          error(null, path, { anno: '@cds.persistence.table' },
+                'Expecting element to have a type if view is annotated with $(ANNO)');
+        }
       });
     }
   }

package/lib/transform/db/constraints.js

@@ -14,7 +14,7 @@ const ASSOCIATION = 'cds.Association';
  * @param {CSN.Model} csn
  * @param {CSN.Options} options are used to modify the validate / enforced flag on the constraints
  */
-function createReferentialConstraints(csn, options) {
+function createReferentialConstraints( csn, options ) {
   let validated = true;
   let enforced = true;
   if (options.integrityNotValidated)
@@ -77,7 +77,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Artifact} parent artifact containing the composition
    * @param {CSN.Path} path
    */
-  function foreignKeyConstraintForUpLinkOfComposition(composition, parent, path) {
+  function foreignKeyConstraintForUpLinkOfComposition( composition, parent, path ) {
     const dependent = csn.definitions[path[1]];
     if (skipConstraintGeneration(parent, dependent, composition))
       return;
@@ -103,7 +103,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Path} path
    * @param {CSN.PathSegment} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
    */
-  function foreignKeyConstraintForAssociation(association, path, upLinkFor = null) {
+  function foreignKeyConstraintForAssociation( association, path, upLinkFor = null ) {
     const parent = csn.definitions[association.target];
     const dependent = csn.definitions[path[1]];
     if (skipConstraintGeneration(parent, dependent, association))
@@ -136,7 +136,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.PathSegment} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
    *                                    it is used for a comment in the constraint, which is only printed out in test-mode
    */
-  function attachConstraintsToDependentKeys(dependentKeys, parentKeys, parentTable, sourceAssociation, upLinkFor = null) {
+  function attachConstraintsToDependentKeys( dependentKeys, parentKeys, parentTable, sourceAssociation, upLinkFor = null ) {
     while (dependentKeys.length > 0) {
       const dependentKeyValuePair = dependentKeys.pop();
       const dependentKey = dependentKeyValuePair[1];
@@ -178,7 +178,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Path} path the path to the element
    * @returns {boolean} indicating whether the association / composition is a constraint candidate
    */
-  function hasConstraintCompliantOnCondition(element, siblingElements, path) {
+  function hasConstraintCompliantOnCondition( element, siblingElements, path ) {
     const onCondition = element.on;
     const allowedTokens = [ '=', 'and', '(', ')' ];
     // on condition must only contain logical operator 'AND'
@@ -266,7 +266,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Association} element the composition or association
    * @returns {boolean}
    */
-  function skipConstraintGeneration(parent, dependent, element) {
+  function skipConstraintGeneration( parent, dependent, element ) {
     // if set to 'off' don't even bother, just skip all constraints
     if (options.assertIntegrity === false || options.assertIntegrity === 'false')
       return true;
@@ -390,7 +390,7 @@ function createReferentialConstraints(csn, options) {
      * @param {string|boolean} value
      * @returns {boolean}
      */
-    function isAssertIntegrityAnnotationSetTo(value) {
+    function isAssertIntegrityAnnotationSetTo( value ) {
       return hasAnnotationValue(element, '@assert.integrity', value, true);
     }
 
@@ -401,7 +401,7 @@ function createReferentialConstraints(csn, options) {
      * @param {string} prop
      * @param {object} val
      */
-    function assignPropOnBacklinkIfPossible(prop, val) {
+    function assignPropOnBacklinkIfPossible( prop, val ) {
       if (!element.$selfOnCondition)
         return;
       const target = csn.definitions[element.target];
@@ -418,7 +418,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Composition} composition the composition which might be treated like an association
    * @returns {boolean} true if the composition should be treated as an association in regards to foreign key constraints
    */
-  function treatCompositionLikeAssociation(composition) {
+  function treatCompositionLikeAssociation( composition ) {
     return Boolean(isToOne(composition) && composition.keys);
   }
 
@@ -428,7 +428,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Association|CSN.Composition} assocOrComposition
    * @returns {boolean}
    */
-  function isToOne(assocOrComposition) {
+  function isToOne( assocOrComposition ) {
     const { min, max } = assocOrComposition.cardinality || {};
     return !min && !max || max === 1;
   }
@@ -440,7 +440,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Elements} targetElements elements of association/composition target entity
    * @returns {Map} of target elements with their name as key
    */
-  function elementsOfTargetSide(on, targetElements) {
+  function elementsOfTargetSide( on, targetElements ) {
     const elements = new Map();
     on.filter(element => typeof element === 'object' &&
       element.ref.length > 1 &&
@@ -459,7 +459,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Elements} sourceElements elements of source entity where the association/composition is defined.
    * @returns {Map} of source elements with their name as key
    */
-  function elementsOfSourceSide(on, sourceElements) {
+  function elementsOfSourceSide( on, sourceElements ) {
     const elements = new Map();
     on.filter(element => typeof element === 'object' &&
       element.ref.length === 1 &&
@@ -481,7 +481,7 @@ function createReferentialConstraints(csn, options) {
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
-  function collectAndAttachReferentialConstraints(artifact, artifactName) {
+  function collectAndAttachReferentialConstraints( artifact, artifactName ) {
     const referentialConstraints = Object.create(null);
     for (const elementName in artifact.elements) {
       const element = artifact.elements[elementName];
@@ -546,7 +546,7 @@ function createReferentialConstraints(csn, options) {
  * @param {CSN.Path} path
  * @param {Function} error
  */
-function assertConstraintIdentifierUniqueness(artifact, artifactName, path, error) {
+function assertConstraintIdentifierUniqueness( artifact, artifactName, path, error ) {
   // can only happen if referential & unique constraints are present
   if (!(artifact.$tableConstraints && artifact.$tableConstraints.referential && artifact.$tableConstraints.unique))
     return;

package/lib/transform/db/expansion.js

@@ -23,7 +23,7 @@ const { forEach } = require('../../utils/objectUtils');
  * @param {Function} messageFunctions.throwWithAnyError
  * @param {object} iterateOptions
  */
-function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {}) {
+function expandStructureReferences( csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {} ) {
   const csnUtils = getUtils(csn);
   const {
     isStructured, get$combined, getFinalBaseTypeWithProps,
@@ -62,7 +62,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    * For such skipped things, error for usage of assoc pointing to them and and ignore publishing of assoc pointing to them.
    */
   function rewriteExpandInline() {
-    let cleanup;
+    let cleanup = [];
     let _dependents;
 
     const entity = findAnEntity();
@@ -81,7 +81,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
            * Do not remove unexpandable many columns in OData
           */
           if (rewritten.toMany.length > 0 && !options.toOdata) {
-            markAsToDummyfy(artifact, path[1]);
+            markAsToDummify(artifact, path[1]);
             error( null, [ 'definitions', path[1] ], { name: path[1] }, 'Unexpected .expand with to-many association in entity $(NAME)');
           }
           else {
@@ -96,12 +96,10 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     if (!options.toOdata)
       dummyfy();
 
-    if (cleanup)
-      cleanup.forEach(fn => fn());
+    cleanup.forEach(fn => fn());
 
     ({ effectiveType, inspectRef } = csnRefs(csn));
 
-
     const publishing = [];
     // OData must allow navigations to @cds.persistence.skip targets
     // as valid navigations in the API
@@ -134,7 +132,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {Array} parts
      * @param {CSN.Path} path
      */
-    function check(parent, name, parts, path) {
+    function check( parent, name, parts, path ) {
       const inColumns = name === 'columns';
       const kill = [];
       for (let i = 0; i < parts.length; i++) {
@@ -207,8 +205,8 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {CSN.Artifact} artifact
      * @param {string} name
      */
-    function markAsToDummyfy(artifact, name) {
-      if (!_dependents && !cleanup)
+    function markAsToDummify( artifact, name ) {
+      if (!_dependents && cleanup.length === 0)
         ({ cleanup, _dependents } = setDependencies(csn, csnUtils));
 
       const stack = [ [ artifact, name ] ];
@@ -240,7 +238,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {CSN.Artifact} base The current base
      * @returns {CSN.Artifact}
      */
-    function nextBase(parent, base) {
+    function nextBase( parent, base ) {
       if (parent.ref) {
         const finalBaseType = getFinalBaseTypeWithProps(parent._art.type);
         const art = parent._art;
@@ -262,7 +260,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {string[]} excluding
      * @returns {{columns: Array, toMany: Array}} Object with rewritten columns (.expand/.inline) and with any .expand + to-many
      */
-    function rewrite(root, columns, excluding) {
+    function rewrite( root, columns, excluding ) {
       const allToMany = [];
       const newThing = [];
       const containsExpandInline = columns.some(col => col.expand || col.inline);
@@ -299,7 +297,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {CSN.Element} obj
      * @returns {boolean}
      */
-    function isToMany(obj) {
+    function isToMany( obj ) {
       if (!obj._art)
         return false;
       const eType = effectiveType(obj._art);
@@ -318,7 +316,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {Array} alias Any start-alias
      * @returns {{expanded: Array, toManys: Array}} Object with expanded .expand/.inline and with any .expand + to-many
      */
-    function expandInline(root, col, ref, alias) {
+    function expandInline( root, col, ref, alias ) {
       const toManys = [];
       const expanded = [];
       const stack = [ [ root, col, ref, alias ] ];
@@ -376,7 +374,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {object} parent Thing that has an .xpr/.args
      * @param {string[]} ref Ref so far
      */
-    function rewriteExpressionArrays(parent, ref) {
+    function rewriteExpressionArrays( parent, ref ) {
       const stack = [ [ parent, ref ] ];
       while (stack.length > 0) {
         const [ current, currentRef ] = stack.pop();
@@ -397,7 +395,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {object} parent
      * @param {Array} ref The so-far effective name (basically the will-be alias), as an array to treat like a ref
      */
-    function rewriteOn(parent, ref) {
+    function rewriteOn( parent, ref ) {
       const stack = [ [ parent, ref ] ];
       while (stack.length > 0) {
         const [ current, currentRef ] = stack.pop();
@@ -418,7 +416,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {Array} currentRef
      * @param {Array} stack
      */
-    function rewriteOnCondition(on, currentRef, stack) {
+    function rewriteOnCondition( on, currentRef, stack ) {
       for (let i = 0; i < on.length; i++) {
         const part = on[i];
         if (part.ref && part.ref[0] !== '$self' && part.ref[0] !== '$projection') {
@@ -439,7 +437,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {Array} currentRef
      * @param {Array} stack
      */
-    function rewriteSingleExpressionArray(expressionArray, currentRef, stack) {
+    function rewriteSingleExpressionArray( expressionArray, currentRef, stack ) {
       for (let i = 0; i < expressionArray.length; i++) {
         const part = expressionArray[i];
         if (part.ref) {
@@ -472,7 +470,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {string} source
      * @returns {CSN.Artifact}
      */
-    function createDummyView(source) {
+    function createDummyView( source ) {
       const elements = Object.create(null);
       elements.one = {
         '@Core.Computed': true,
@@ -517,7 +515,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    * @param {boolean} [withAlias=false] Whether to "expand" the (implicit) alias aswell.
    * @returns {Array} New array - with all structured things expanded
    */
-  function expand(thing, path, withAlias = false) {
+  function expand( thing, path, withAlias = false ) {
     const newThing = [];
     for (let i = 0; i < thing.length; i++) {
       const col = thing[i];
@@ -553,7 +551,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    * @param {boolean} withAlias
    * @returns {Array}
    */
-  function expandRef(art, ref, alias, isKey, withAlias) {
+  function expandRef( art, ref, alias, isKey, withAlias ) {
     const expanded = [];
     /** @type {Array<[CSN.Element, any[], any[]]>} */
     const stack = [ [ art, ref, [ alias || ref[ref.length - 1] ] ] ];
@@ -588,7 +586,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    * @param {object} part A thing with a ref/as/func
    * @returns {string}
    */
-  function dbName(part) {
+  function dbName( part ) {
     if (part.as)
       return part.as;
     else if (part.ref)
@@ -606,7 +604,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
    * @param {string[]} [excluding=[]]
    * @returns {Array} If there was a star, expand it and handle shadowing/excluding, else just return subs
    */
-  function replaceStar(base, subs, excluding = []) {
+  function replaceStar( base, subs, excluding = [] ) {
     const stars = [];
     const names = Object.create(null);
     for (let i = 0; i < subs.length; i++) {