@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/base/optionProcessorHelper.js

@@ -30,7 +30,11 @@ function createOptionProcessor() {
     optionClashes: [],
     option,
     command,
-    positionalArgument,
+    positionalArgument: (argumentDefinition) => {
+      // Default positional arguments; may be overwritten by commands.
+      _positionalArguments(argumentDefinition);
+      return optionProcessor;
+    },
     help,
     processCmdLine,
     verifyOptions,
@@ -66,7 +70,12 @@ function createOptionProcessor() {
     /** @type {object} */
     const command = {
       options: {},
+      positionalArguments: [],
       option,
+      positionalArgument: (argumentDefinition) => {
+        _positionalArguments(argumentDefinition, command.positionalArguments);
+        return command;
+      },
       help,
       ..._parseCommandString(cmdString)
     };
@@ -96,28 +105,34 @@ function createOptionProcessor() {
   }
 
   /**
-   * Adds positional arguments to the command line processor. Instructs the processor
-   * to either require N positional arguments or a dynamic number (but at least one)
-   * @param {string} positionalArgumentDefinition Positional arguments, e.g. '<input> <output>' or '<files...>'
+   * Set the positional arguments to the command line processor. Instructs the processor
+   * to either require N positional arguments or a dynamic number (but at least one).
+   * Note that you can only call this function once.  Only the last invocation sets
+   * the positional arguments.
+   *
+   * @param {string}   argumentDefinition Positional arguments, e.g. '<input> <output>' or '<files...>'
+   * @param {object[]} argList            Array, to which the parsed arguments will be added.  Default is global scope.
    */
-  function positionalArgument(positionalArgumentDefinition) {
-    if (optionProcessor.positionalArguments.find((arg) => arg.isDynamic)) {
+  function _positionalArguments(argumentDefinition, argList = optionProcessor.positionalArguments) {
+    if (argList.find((arg) => arg.isDynamic)) {
       throw new Error(`Can't add positional arguments after a dynamic one`);
     }
 
-    const registeredNames = optionProcessor.positionalArguments.map((arg) => arg.name);
-    const args = positionalArgumentDefinition.split(' ');
+    const registeredNames = argList.map((arg) => arg.name);
+    const args = argumentDefinition.split(' ');
 
     for (const arg of args) {
-      const argName = arg.replace('<', '').replace('>', '').replace('...', '');
+      // Remove braces, dots and camelify.
+      const argName = arg.replace('<', '').replace('>', '').replace('...', '').replace(/[ -]./g, s => s.substring(1).toUpperCase());
+
       if (registeredNames.includes(argName)) {
-        throw new Error(`Duplicate positional argument ${arg}`);
+        throw new Error(`Duplicate positional argument: ${arg}`);
       }
       if (!isParam(arg) && !isDynamicPositionalArgument(arg)) {
         throw new Error(`Unknown positional argument syntax: ${arg}`)
       }
 
-      optionProcessor.positionalArguments.push({
+      argList.push({
         name: argName,
         isDynamic: isDynamicPositionalArgument(arg),
         required: true
@@ -125,7 +140,6 @@ function createOptionProcessor() {
 
       registeredNames.push(argName);
     }
-    return optionProcessor;
   }
 
   /**
@@ -390,21 +404,38 @@ function createOptionProcessor() {
     }
 
     // Complain about first missing positional arguments
-    const missingArg = optionProcessor.positionalArguments.find((arg) => arg.required && !result.args[arg.name]);
+    const missingArg = getCurrentPositionArguments().find((arg) => arg.required && !result.args[arg.name]);
     if (missingArg) {
-      result.errors.push(`Missing positional argument: <${missingArg.name}${missingArg.isDynamic ? '...' : ''}>`)
+      const forCommand = result.command ? ` for '${ result.command }'` : '';
+      result.errors.push(`Missing positional argument${forCommand}: <${missingArg.name}${missingArg.isDynamic ? '...' : ''}>`)
     }
 
     return result;
 
+    /**
+     * Specific commands may have custom positional arguments.
+     * If the current one does, use it instead of the defaults.
+     *
+     * @returns {object[]} Array of positional argument configurations.
+     */
+    function getCurrentPositionArguments() {
+      const cmd = optionProcessor.commands[result.command];
+      const args = ( cmd && cmd.positionalArguments && cmd.positionalArguments.length ) ? cmd.positionalArguments : optionProcessor.positionalArguments;
+      return args;
+    }
+
     function processPositionalArgument(argumentValue) {
-      if ( result.args.length === 0 && optionProcessor.positionalArguments.length === 0 )
+      const argList = getCurrentPositionArguments();
+      if ( result.args.length === 0 && argList.length === 0 )
         return;
-      const inBounds = result.args.length < optionProcessor.positionalArguments.length;
-      const lastIndex = inBounds ? result.args.length : optionProcessor.positionalArguments.length - 1;
-      const nextUnsetArgument = optionProcessor.positionalArguments[lastIndex];
+      const inBounds = result.args.length < argList.length;
+      const lastIndex = inBounds ? result.args.length : argList.length - 1;
+      const nextUnsetArgument = argList[lastIndex];
       if (!inBounds && !nextUnsetArgument.isDynamic) {
-        result.errors.push(`Too many arguments. Expected ${optionProcessor.positionalArguments.length}`);
+        if (result.command)
+          result.errors.push(`Too many arguments. '${result.command}' expects ${argList.length}`);
+        else
+          result.errors.push(`Too many arguments. Expected ${argList.length}`);
         return;
       }
       result.args.length += 1;
@@ -486,7 +517,10 @@ function createOptionProcessor() {
     }
 
     if(options) {
-      ['defaultStringLength', /*'length', 'precision', 'scale'*/].forEach(facet => {
+      [
+        'defaultBinaryLength', 'defaultStringLength',
+        /*'length', 'precision', 'scale'*/
+      ].forEach(facet => {
         if(options[facet] && isNaN(options[facet])) {
           result.push(`Invalid value "${options[facet]}" for option "--${facet}" - not an Integer`);
         } else {
@@ -577,12 +611,12 @@ function isLongOption(opt) {
 
 // Check if 'opt' looks like a "<foobar>" parameter
 function isParam(opt) {
-  return /^<[a-zA-Z]+>$/.test(opt);
+  return /^<[a-zA-Z-]+>$/.test(opt);
 }
 
 // Check if 'arg' looks like "<foobar...>"
 function isDynamicPositionalArgument(arg) {
-  return /^<[a-zA-Z]+[.]{3}>$/.test(arg);
+  return /^<[a-zA-Z-]+[.]{3}>$/.test(arg);
 }
 
 module.exports = {

package/lib/checks/defaultValues.js

@@ -35,8 +35,33 @@ function validateDefaultValues(member, memberName, prop, path) {
  * @param {CSN.Path} path Path to the member
  */
 function rejectParamDefaultsInHanaCds(member, memberName, prop, path) {
-  if (member.default && prop === 'params' && this.options.toHana)
+  if (member.default && prop === 'params' && this.options.transformation === 'hdbcds')
     this.error(null, path, 'Parameter default values are not supported in SAP HANA CDS');
 }
 
-module.exports = { validateDefaultValues, rejectParamDefaultsInHanaCds };
+/**
+ * For HANA CDS, we render a default for a mixin if the projected entity contains
+ * a derived association with a default defined on it. This leads to a deployment error
+ * and should be warned about.
+ *
+ * @param {CSN.Element} member Member to validate
+ * @param {string} memberName Name of the member
+ * @param {string} prop Property being looped over
+ * @param {CSN.Path} path Path to the member
+ */
+function warnAboutDefaultOnAssociationForHanaCds(member, memberName, prop, path) {
+  const art = this.csn.definitions[path[1]];
+  if (!art.query && this.options.transformation === 'hdbcds' && member.target && member.default) {
+    this.warning(null, path, { '#': member._type.type === 'cds.Association' ? 'std' : 'comp' },
+                 {
+                   std: 'Unexpected default defined on association',
+                   comp: 'Unexpected default defined on composition',
+                 });
+  }
+}
+
+module.exports = {
+  validateDefaultValues,
+  rejectParamDefaultsInHanaCds,
+  warnAboutDefaultOnAssociationForHanaCds,
+};

package/lib/checks/elements.js

@@ -2,7 +2,6 @@
 
 const { forEachMember, forEachMemberRecursively } = require('../model/csnUtils');
 const { isGeoTypeName } = require('../compiler/builtins');
-const { isBetaEnabled } = require('../base/model');
 
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
@@ -103,15 +102,11 @@ function checkVirtualElement(member) {
  * @param {CSN.Artifact} art The artifact
  */
 function checkManagedAssoc(art) {
-  forEachMemberRecursively(art, (member, memberName) => {
+  forEachMemberRecursively(art, (member) => {
     if (this.csnUtils.isAssocOrComposition(member.type) &&
         !isManagedComposition.bind(this)(member)) {
       if (member.on)
         return;
-      if (!isBetaEnabled(this.options, 'keylessManagedAssoc') && (!member.keys || member.keys.length === 0)) {
-        this.error(null, member.$path, { name: memberName },
-                   `The managed association $(NAME) has no foreign keys`);
-      }
       const max = member.cardinality && member.cardinality.max;
       if (max === '*' || Number(max) > 1) {
         const isNoDb = art['@cds.persistence.skip'] || art['@cds.persistence.exists'];

package/lib/checks/foreignKeys.js

@@ -1,7 +1,5 @@
 'use strict';
 
-const { isBetaEnabled } = require('../base/model');
-
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
@@ -20,17 +18,13 @@ function validateForeignKeys(member) {
 
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem) => {
-    let elementCount = 0;
     for (let i = 0; i < mem.keys.length; i++) {
       if (mem.keys[i].ref) {
         if (!mem.keys[i]._art)
           continue;
         // eslint-disable-next-line no-use-before-define
         checkForItems(mem.keys[i]._art);
-        elementCount++;
       }
-      if (!isBetaEnabled(this.options, 'keylessManagedAssoc') && elementCount === 0)
-        this.error(null, member.$path, 'Empty structured types/elements must not be used as foreign keys');
     }
   };
 

package/lib/checks/managedWithoutKeys.js

@@ -0,0 +1,17 @@
+'use strict';
+
+
+/**
+ * Trigger a recompilation in case of an association without .keys and without .on
+ *
+ * @param {CSN.Element} member the element to be checked
+ * @param {string} memberName the elements name
+ * @param {string} prop which kind of member are we looking at -> only prop "elements"
+ */
+function managedWithoutKeys(member, memberName, prop) {
+  if (prop === 'elements' && member.target && !member.keys && !member.on) { // trigger recompilation
+    throw new Error('Expected association to have either an on-condition or foreign keys.');
+  }
+}
+
+module.exports = managedWithoutKeys;

package/lib/checks/nonexpandableStructured.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { otherSideIsExpandableStructure, resolveArtifactType } = require('./utils');
+
+/**
+ * Check the given expression for non-expandable structure usage
+ *
+ * @param {object} parent Object with the expression as a property
+ * @param {string} name Name of the expression property on parent
+ * @param {Array} expression Expression to check - .on .xpr .having and .where
+ */
+function nonexpandableStructuredInExpression(parent, name, expression) {
+  for (let i = 0; i < expression.length; i++) {
+    if (expression[i].ref) {
+      const { ref } = expression[i];
+      // eslint-disable-next-line prefer-const
+      let { _art, $scope } = expression[i];
+      if (!_art)
+        continue;
+      const validStructuredElement = otherSideIsExpandableStructure.call(this, expression, i);
+      if (_art) {
+        _art = resolveArtifactType.call(this, _art);
+        // Paths of an expression may end on a structured element only if both operands in the expression end on a structured element
+        if (_art.elements && !validStructuredElement && $scope !== '$self') { // TODO: Use $self to navigate to struct
+          this.error(null, expression[i].$path, { elemref: { ref } },
+                     'Unexpected usage of structured type $(ELEMREF)');
+        }
+      }
+    }
+  }
+}
+
+module.exports = {
+  on: nonexpandableStructuredInExpression,
+  having: nonexpandableStructuredInExpression,
+  where: nonexpandableStructuredInExpression,
+  xpr: nonexpandableStructuredInExpression,
+};

package/lib/checks/onConditions.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { forEachGeneric, isBuiltinType } = require('../model/csnUtils');
+const { forEachGeneric } = require('../model/csnUtils');
+const { otherSideIsExpandableStructure, resolveArtifactType } = require('./utils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -42,48 +43,6 @@ function otherSideIsValidDollarSelf(on, startIndex) {
   return false;
 }
 
-/**
- * Check that the opposite operand to a relational term is something
- * structured that can be used for tuple expansion. This can either be a
- * real 'elements' thing or a managed association/composition with foreign keys.
- *
- * @param {Array} on the on condition which to check
- * @param {number} startIndex the index of the relational term in the on condition array
- * @returns {boolean} indicates whether the other side of a relational term is expandable
- */
-function otherSideIsExpandableStructure(on, startIndex) {
-  if (on[startIndex - 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex - 1]))
-    return isOk(resolveArtifactType.call(this, on[startIndex - 2]._art));
-
-  else if (on[startIndex + 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex + 1]))
-    return isOk(resolveArtifactType.call(this, on[startIndex + 2]._art));
-
-  return false;
-
-  /**
-   * Artifact is structured or a managed association/compoisition
-   *
-   * @param {CSN.Artifact} art Artifact
-   * @returns {boolean} True if expandable
-   */
-  function isOk(art) {
-    return !!(art && (art.elements || (art.target && art.keys)));
-  }
-}
-
-/**
- * Get the real type of an artifact
- *
- * @param {object} art Whatever _art by csnRefs can be - element or artifact
- * @returns {object} final artifact type
- */
-function resolveArtifactType(art) {
-  if (art && art.type && !isBuiltinType(art.type))
-    return this.getFinalBaseType(art);
-
-  return art;
-}
-
 /**
  * Validate an on-condition
  *
@@ -100,6 +59,11 @@ function resolveArtifactType(art) {
  */
 function validateOnCondition(member, memberName, property, path) {
   if (member && member.on) {
+    // complain about nullability constraint on managed composition
+    if (member.targetAspect && {}.hasOwnProperty.call(member, 'notNull')) {
+      this.warning(null, path.concat([ 'on' ]),
+                   'Unexpected nullability constraint defined on managed composition');
+    }
     for (let i = 0; i < member.on.length; i++) {
       if (member.on[i].ref) {
         const { ref } = member.on[i];
@@ -148,8 +112,8 @@ function validateOnCondition(member, memberName, property, path) {
           // 2) Path ends on an association (managed or unmanaged) and the other operand is a '$self'
 
           // If this path ends structured or on an association, perform the check:
-          if ((_art.elements || _art.target) &&
-             !( /* 1) */ (_art.elements || _art.target && _art.keys) && validStructuredElement ||
+          if ((_art.target) &&
+             !( /* 1) */ (_art.target && _art.keys) && validStructuredElement ||
              /* 2) */ (_art.target && validDollarSelf)) &&
              !_art.virtual) {
             this.error(null, onPath, { elemref: { ref } },

package/lib/checks/queryNoDbArtifacts.js

@@ -69,13 +69,31 @@ function checkQueryForNoDBArtifacts(query) {
       const pathStep = obj.ref[i].id ? obj.ref[i].id : obj.ref[i];
       const name = art.target ? art.target : pathStep;
       if (!isPersistedOnDatabase(endArtifact)) {
-        const cdsPersistenceSkipped = hasAnnotationValue(endArtifact, '@cds.persistence.skip');
-        this.error( null, obj.$path, {
-          id: pathStep, elemref: obj, name, '#': cdsPersistenceSkipped ? 'std' : 'abstract',
-        }, {
-          std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
-          abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
-        } );
+        const nextElement = obj.ref[i + 1];
+        /**
+         * if we only navigate to foreign keys of the managed association in a view, we do not need to join,
+         * thus we can produce the view even if the target of the association is not persisted
+         *
+         * @param {CSN.Element} assoc association in ref
+         * @param {string} nextStep the ref step following the association
+         * @returns {boolean} true if no join will be generated
+         */
+        const isJoinRelevant = (assoc, nextStep) => {
+          if (!assoc.keys)
+            return true;
+          const isExposedColumnAssocOrComposition = this.csnUtils.isAssocOrComposition(obj._art.type);
+          return !assoc.keys
+            .some(fk => fk.ref[0] === nextStep && !isExposedColumnAssocOrComposition);
+        };
+        if (isJoinRelevant(art, nextElement)) {
+          const cdsPersistenceSkipped = hasAnnotationValue(endArtifact, '@cds.persistence.skip');
+          this.error( null, obj.$path, {
+            id: pathStep, elemref: obj, name, '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+          }, {
+            std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
+            abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
+          } );
+        }
       }
       // check managed association to have foreign keys array filled
       if (art.keys && leafCount(art) === 0) {

package/lib/checks/selectItems.js

@@ -11,7 +11,7 @@ const { forEachGeneric } = require('../model/csnUtils');
  */
 function validateSelectItems(query) {
   const { SELECT } = query;
-  if (!SELECT || !SELECT.columns)
+  if (!SELECT)
     return;
 
   forEachGeneric(SELECT, 'columns', (selectItem) => {
@@ -23,6 +23,33 @@ function validateSelectItems(query) {
                    'Select items starting with $(NAME) must not contain path steps of type $(TYPE)');
       }
     }
+    else if (this.options.transformation === 'hdbcds' && selectItem.xpr && selectItem.func) {
+      this.error(null, selectItem.$path,
+                 'Window functions are not supported by SAP HANA CDS');
+    }
   });
+  // .call() with 'this' to ensure we have access to the options
+  rejectManagedAssociationsAndStructuresForHdbcsNames.call(this, SELECT, SELECT.$path);
+}
+
+
+/**
+ * For the to.hdbcds transformation with naming mode 'hdbcds', structures and managed associations are not flattened/resolved.
+ * It is therefore not possible to publish such elements in a view.
+ * This function iterates over all published elements of a query artifact and asserts that no such elements are published.
+ *
+ * @param {CSN.Artifact} queryArtifact the query artifact which should be checked
+ * @param {CSN.Path} artifactPath the path to that artifact
+ */
+function rejectManagedAssociationsAndStructuresForHdbcsNames(queryArtifact, artifactPath) {
+  if (this.options.transformation === 'hdbcds' && this.options.sqlMapping === 'hdbcds') {
+    forEachGeneric(queryArtifact, 'elements', (selectItem, elemName, prop, elementPath) => {
+      if (this.csnUtils.isManagedAssociationElement(selectItem))
+        this.error('query-unexpected-assoc-hdbcds', elementPath);
+      if (this.csnUtils.isStructured(selectItem))
+        this.error('query-unexpected-structure-hdbcds', elementPath);
+    }, artifactPath);
+  }
 }
-module.exports = validateSelectItems;
+
+module.exports = { validateSelectItems, rejectManagedAssociationsAndStructuresForHdbcsNames };

package/lib/checks/types.js

@@ -1,9 +1,28 @@
 'use strict';
 
-const { getUtils, isBuiltinType } = require('../model/csnUtils');
+const { getUtils, isBuiltinType, hasAnnotationValue } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
+/**
+ * Scale must not be 'variable' or 'floating'
+ *
+ * scale property is always propagated
+ *
+ * @param {CSN.Element} member the element to be checked
+ * @param {string} memberName the elements name
+ * @param {string} prop which kind of member are we looking at -> only prop "elements"
+ * @param {CSN.Path} path the path to the member
+ */
+function checkDecimalScale(member, memberName, prop, path) {
+  if (hasAnnotationValue(this.artifact, '@cds.persistence.exists') ||
+     // skip is already filtered in validator, here for completeness
+     hasAnnotationValue(this.artifact, '@cds.persistence.skip'))
+    return;
+  if (member.scale && [ 'variable', 'floating' ].includes(member.scale))
+    this.error(null, path, { name: member.scale }, 'Unexpected scale $(NAME)');
+}
+
 /**
  * View parameter for hana must be of scalar type
  *
@@ -165,4 +184,9 @@ function hasArtifactTypeInformation(artifact) {
     artifact.type;     // => `type A : [type of] Integer`
 }
 
-module.exports = { checkTypeDefinitionHasType, checkElementTypeDefinitionHasType, checkTypeIsScalar };
+module.exports = {
+  checkTypeDefinitionHasType,
+  checkElementTypeDefinitionHasType,
+  checkTypeIsScalar,
+  checkDecimalScale,
+};

package/lib/checks/unknownMagic.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { getVariableReplacement } = require('../model/csnUtils');
+
+// We only care about the "wild" ones - $at is validated by the compiler
+const magicVariables = {
+  $user: [
+    'id',     // $user.id
+    'locale', // $user.locale
+  ],
+  $session: [
+    // no valid ways for this
+  ],
+};
+
+/**
+ * Check that the given ref does not use magic variables for which we don't have
+ * a valid way of rendering.
+ *
+ * Valid ways:
+ * - We know what to do -> $user.id on HANA
+ * - The user tells us what to do -> options.variableReplacements
+ *
+ * @param {object} parent Object with the ref as a property
+ * @param {string} name Name of the ref property on parent
+ * @param {Array} ref to check
+ */
+function unknownMagicVariable(parent, name, ref) {
+  if (parent.$scope && parent.$scope === '$magic') {
+    const [ head, ...rest ] = ref;
+    const tail = rest.join('.');
+    const magicVariable = magicVariables[head];
+    if (magicVariable && magicVariable.indexOf(tail) === -1 &&
+          getVariableReplacement(ref, this.options) === null)
+      this.error(null, parent.$location, { id: tail, elemref: parent }, 'No configuration for magic variable was provided - path $(ELEMREF), step $(ID)');
+  }
+}
+
+module.exports = {
+  ref: unknownMagicVariable,
+};

package/lib/checks/utils.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const { isBuiltinType } = require('../model/csnUtils');
+
+/**
+ * Prepare the ref steps so that they are loggable
+ *
+ * @param {any} refStep part of a ref
+ * @returns {string} Loggable string
+ */
+function logReady(refStep) {
+  return refStep.id || refStep;
+}
+
+/**
+ * Check that the opposite operand to a relational term is something
+ * structured that can be used for tuple expansion. This can either be a
+ * real 'elements' thing or a managed association/composition with foreign keys.
+ *
+ * @param {Array} on the on condition which to check
+ * @param {number} startIndex the index of the relational term in the on condition array
+ * @returns {boolean} indicates whether the other side of a relational term is expandable
+ */
+function otherSideIsExpandableStructure(on, startIndex) {
+  if (on[startIndex - 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex - 1]))
+    return isOk(resolveArtifactType.call(this, on[startIndex - 2]._art));
+
+  else if (on[startIndex + 1] && [ '=', '<', '>', '>=', '<=', '!=', '<>' ].includes(on[startIndex + 1]))
+    return isOk(resolveArtifactType.call(this, on[startIndex + 2]._art));
+
+  return false;
+
+  /**
+   * Artifact is structured or a managed association/compoisition
+   *
+   * @param {CSN.Artifact} art Artifact
+   * @returns {boolean} True if expandable
+   */
+  function isOk(art) {
+    return !!(art && (art.elements || (art.target && art.keys)));
+  }
+}
+
+/**
+ * Get the real type of an artifact
+ *
+ * @param {object} art Whatever _art by csnRefs can be - element or artifact
+ * @returns {object} final artifact type
+ */
+function resolveArtifactType(art) {
+  if (art && art.type && !isBuiltinType(art.type))
+    return this.getFinalBaseType(art);
+
+  return art;
+}
+
+module.exports = {
+  logReady,
+  otherSideIsExpandableStructure,
+  resolveArtifactType,
+};