@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/base/model.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { forEach } = require("../utils/objectUtils");
+
 const queryOps = {
   query: 'select',                // TODO: rename to SELECT
   union: 'union',
@@ -20,7 +22,6 @@ const queryOps = {
 const availableBetaFlags = {
   // enabled by --beta-mode
   toRename: true,
-  addTextsLanguageAssoc: true,
   assocsWithParams: true,
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true,
@@ -29,6 +30,8 @@ const availableBetaFlags = {
   enableUniversalCsn: true,
   // disabled by --beta-mode
   nestedServices: false,
+  odataOpenType: true,
+  optionalActionFunctionParameters: true,
 };
 
 /**
@@ -58,16 +61,56 @@ function isBetaEnabled( options, feature ) {
  * Please do not move this function to the "option processor" code.
  *
  * @param {object} options Options
- * @param {string} [feature] Feature to check for
+ * @param {string|null} [feature] Feature to check for
  * @returns {boolean}
  */
 function isDeprecatedEnabled( options, feature = null ) {
   const { deprecated } = options;
   if (!feature)
     return !!deprecated;
+
   return deprecated && typeof deprecated === 'object' && deprecated[feature];
 }
 
+const oldDeprecatedFlags_v2 = [
+  'createLocalizedViews',
+  'downgradableErrors',
+  'generatedEntityNameWithUnderscore',
+  'longAutoexposed',
+  'noElementsExpansion',
+  'noInheritedAutoexposeViaComposition',
+  'noScopedRedirections',
+  'oldVirtualNotNullPropagation',
+  'parensAsStrings',
+  'projectionAsQuery',
+  'redirectInSubQueries',
+  'renderVirtualElements',
+  'shortAutoexposed',
+  'unmanagedUpInComponent',
+  'v1KeysForTemporal',
+];
+
+/**
+ * In cds-compiler v3, we removed old v2 deprecated flags.  That can lead to silent
+ * errors such as entity/view names changing.  To ensure that the user is forced
+ * to change their code, emit an error if one of such removed flags was used.
+ *
+ * @param {CSN.Options} options
+ * @param error Error message function returned by makeMessageFunctions().
+ */
+function checkRemovedDeprecatedFlags( options, { error } ) {
+  // Assume that we emitted these errors once if a message with this ID was found.
+  if (!options.deprecated || options.messages?.some(m => m.messageId === 'api-invalid-deprecated'))
+    return;
+
+  forEach(options.deprecated, (key, val) => {
+    if (val && oldDeprecatedFlags_v2.includes(key)) {
+      error('api-invalid-deprecated', null, { name: key },
+        'Deprecated flag $(NAME) has been removed in CDS compiler v3');
+    }
+  });
+}
+
 // Apply function `callback` to all artifacts in dictionary
 // `model.definitions`.  See function `forEachGeneric` for details.
 function forEachDefinition( model, callback ) {
@@ -129,6 +172,7 @@ module.exports = {
   isBetaEnabled,
   availableBetaFlags,
   isDeprecatedEnabled,
+  checkRemovedDeprecatedFlags,
   queryOps,
   forEachDefinition,
   forEachMember,

package/lib/base/optionProcessorHelper.js

@@ -153,36 +153,67 @@ function createOptionProcessor() {
    * Internal: Define a general or command option.
    * Throws if the option is already registered in the given command context.
    * or in the given command.
+   *
    * @private
    * @see option()
    */
   function _addOption(cmd, optString, validValues, options) {
-    const opt = _parseOptionString(optString, validValues);
-    Object.assign(opt, options);
+    const cliOpt = _parseOptionString(optString, validValues);
+    Object.assign(cliOpt, options);
+    _addLongOption(cmd, cliOpt.longName, cliOpt);
+    _addShortOption(cmd, cliOpt.shortName, cliOpt);
+
+    for (const alias of cliOpt.aliases || []) {
+      const aliasOpt = Object.assign({ }, cliOpt, { isAlias: true });
+      _addLongOption(cmd, alias, aliasOpt); // use same camelName, etc. for alias
+    }
+
+    return cmd;
+  }
 
-    if (cmd.options[opt.longName]) {
-      throw new Error(`Duplicate assignment for long option ${opt.longName}`);
-    } else if (optionProcessor.options[opt.longName]) {
+  /**
+   * Internal: Add longName to the list of options.
+   * Throws if the option is already registered in the given command context.
+   * or in the given command.
+   * `longName` may differ from `opt.longName`, e.g. for aliases.
+   *
+   * @private
+   * @see _addOption()
+   */
+  function _addLongOption(cmd, longName, opt) {
+    if (cmd.options[longName]) {
+      throw new Error(`Duplicate assignment for long option ${longName}`);
+    } else if (optionProcessor.options[longName]) {
       // This path is only taken if optString is for commands
       optionProcessor.optionClashes.push({
-        option: opt.longName,
-        description: `Command '${cmd.longName}' has option clash with general options for: ${opt.longName}`
+        option: longName,
+        description: `Command '${cmd.longName}' has option clash with general options for: ${longName}`
       });
     }
-    cmd.options[opt.longName] = opt;
-    if (opt.shortName) {
-      if (cmd.options[opt.shortName]) {
-        throw new Error(`Duplicate assignment for short option ${opt.shortName}`);
-      } else if (optionProcessor.options[opt.shortName]) {
-        // This path is only taken if optString is for commands
-        optionProcessor.optionClashes.push({
-          option: opt.shortName,
-          description: `Command '${cmd.longName}' has option clash with general options for: ${opt.shortName}`
-        });
-      }
-      cmd.options[opt.shortName] = opt;
+    cmd.options[longName] = opt;
+  }
+  /**
+   * Internal: Add shortName to the list of options.
+   * Throws if the option is already registered in the given command context.
+   * or in the given command.
+   * `longName` may differ from `opt.longName`, e.g. for aliases.
+   *
+   * @private
+   * @see _addOption()
+   */
+  function _addShortOption(cmd, shortName, opt) {
+    if (!shortName)
+      return;
+    if (cmd.options[shortName]) {
+      throw new Error(`Duplicate assignment for short option ${shortName}`);
+    } else if (optionProcessor.options[shortName]) {
+      // This path is only taken if optString is for commands
+      optionProcessor.optionClashes.push({
+        option: shortName,
+        description: `Command '${cmd.longName}' has option clash with general options for: ${shortName}`
+      });
     }
-    return cmd;
+    cmd.options[shortName] = opt;
   }
 
   // Internal: Parse one command string like "F, toFoo". Return an object like this
@@ -275,7 +306,8 @@ function createOptionProcessor() {
       shortName,
       camelName: camelifyLongOption(longName),
       param,
-      validValues
+      validValues,
+      isAlias: false, // default
     }
   }
 

package/lib/checks/actionsFunctions.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { isBuiltinType } = require('../model/csnUtils');
+const { isBetaEnabled } = require('../base/model');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -16,8 +17,8 @@ function checkActionOrFunction(art, artName, prop, path) {
   if (!(art.kind === 'action' || art.kind === 'function') && !art.actions)
     return;
 
-  // const isMultiSchema = this.options.toOdata.odataFormat === 'structured' &&
-  //   (this.options.toOdata.odataProxies || this.options.toOdata.odataXServiceRefs);
+  // const isMultiSchema = this.options.odataFormat === 'structured' &&
+  //   (this.options.odataProxies || this.options.odataXServiceRefs);
 
   const serviceName = this.csnUtils.getServiceName(artName);
   if (!serviceName)
@@ -52,13 +53,13 @@ function checkActionOrFunction(art, artName, prop, path) {
   function checkActionOrFunctionParameter(param, currPath, actKind) {
     const paramType = param.type ? this.csnUtils.getFinalTypeDef(param.type) : param;
 
-    if (param.default || paramType.default) {
-      this.error('param-default', currPath, { '#': actKind },
-                 {
-                   std: 'Artifact parameters can\'t have a default value', // Not used
-                   action: 'Action parameters can\'t have a default value',
-                   function: 'Function parameters can\'t have a default value',
-                 });
+    if (!isBetaEnabled(this.options, 'optionalActionFunctionParameters') && (param.default || paramType.default)) {
+      this.message('param-default', currPath, { '#': actKind },
+                   {
+                     std: 'Artifact parameters can\'t have a default value', // Not used
+                     action: 'Action parameters can\'t have a default value',
+                     function: 'Function parameters can\'t have a default value',
+                   });
     }
 
     if (paramType.type && this.csnUtils.isAssocOrComposition(param.type)) {
@@ -85,9 +86,11 @@ function checkActionOrFunction(art, artName, prop, path) {
    * @param {string} actKind 'action' or 'function'
    */
   function checkReturns(returns, currPath, actKind) {
-    const finalReturnType = returns.type ? this.csnUtils.getFinalBaseType(returns.type) : returns;
+    const finalReturnType = returns.type ? this.csnUtils.getFinalBaseTypeWithProps(returns.type) : returns;
+    if (!finalReturnType)
+      return; // no type, e.g. `type of V:calculated`; already an error in `checkTypeOfHasProperType()`
 
-    if (this.csnUtils.isAssocOrComposition(finalReturnType)) {
+    if (this.csnUtils.isAssocOrComposition(finalReturnType.type)) {
       this.error(null, currPath, { '#': actKind },
                  {
                    std: 'An association is not allowed as this artifact\'s return type', // Not used
@@ -98,7 +101,7 @@ function checkActionOrFunction(art, artName, prop, path) {
 
     if (finalReturnType.items) // check array return type
       checkReturns.bind(this)(finalReturnType.items, currPath.concat('items'), actKind);
-    else // check if return type is user definited from the current service
+    else // check if return type is user defined from the current service
       checkUserDefinedType.bind(this)(finalReturnType, returns.type, currPath);
   }
 

package/lib/checks/annotationsOData.js

@@ -23,7 +23,7 @@ function checkCoreMediaTypeAllowence(member) {
     'cds.hana.CLOB': 1,
     'cds.hana.BINARY': 1,
   };
-  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseType(member.type) in allowedCoreMediaTypes)) {
+  if (member['@Core.MediaType'] && member.type && !(this.csnUtils.getFinalBaseTypeWithProps(member.type)?.type in allowedCoreMediaTypes)) {
     this.warning(null, member.$path, { names: [ 'Edm.String', 'Edm.Binary' ] },
                  'Element annotated with “@Core.MediaType” should be of a type mapped to $(NAMES)');
   }

package/lib/checks/cdsPersistence.js

@@ -14,6 +14,7 @@ function validateCdsPersistenceAnnotation(artifact, artifactName, prop, path) {
   if (artifact.kind === 'entity') {
     // filter for 'table', 'udf', 'calcview' === true
     const persistenceAnnos = [ '@cds.persistence.table', '@cds.persistence.udf', '@cds.persistence.calcview' ];
+    // TODO: Why not filter over persistenceAnnos, is shorter!
     const TableUdfCv = Object.keys(artifact).filter(p => persistenceAnnos.includes(p) && artifact[p]);
     if (TableUdfCv.length > 1)
       this.error(null, path, `Annotations ${ TableUdfCv.join(', ') } can't be used in combination`);

package/lib/checks/elements.js

@@ -36,10 +36,10 @@ function checkPrimaryKey(art) {
    */
   function checkIfPrimaryKeyIsOfGeoType(member, elemFqName, parentIsKey, parentPath) {
     if (member.key || parentIsKey) {
-      const finalBaseType = this.csnUtils.getFinalBaseType(member.type);
-      if (typeof finalBaseType === 'string' && isGeoTypeName(finalBaseType)) {
+      const finalBaseType = this.csnUtils.getFinalBaseTypeWithProps(member.type);
+      if (isGeoTypeName(finalBaseType?.type)) {
         this.error(null, parentPath || member.$path,
-                   { type: finalBaseType, name: elemFqName },
+                   { type: finalBaseType.type, name: elemFqName },
                    'Type $(TYPE) can\'t be used as primary key in element $(NAME)');
       }
       else if (finalBaseType && this.csnUtils.isStructured(finalBaseType)) {
@@ -63,7 +63,7 @@ function checkPrimaryKey(art) {
    */
   function checkIfPrimaryKeyIsArray(member, elemFqName, parentIsKey, parentPath) {
     if (member.key || parentIsKey) {
-      const finalBaseType = this.csnUtils.getFinalBaseType(member.type);
+      const finalBaseType = this.csnUtils.getFinalBaseTypeWithProps(member.type);
       if (member.items || (finalBaseType && finalBaseType.items)) {
         this.error(null, parentPath || member.$path, { name: elemFqName },
                    'Array-like type in element $(NAME) can\'t be used as primary key');
@@ -96,10 +96,10 @@ function checkVirtualElement(member) {
 
 /**
  * Checks whether managed associations
- * with cardinality 'to many' have an on-condition
- * and if managed associations have foreign keys.
+ * with cardinality 'to many' have an on-condition.
  *
  * @param {CSN.Artifact} art The artifact
+ * @todo this is a member validator, is it not?
  */
 function checkManagedAssoc(art) {
   forEachMemberRecursively(art, (member) => {

package/lib/checks/invalidTarget.js

@@ -26,7 +26,7 @@ function invalidTarget(member) {
       if (!target)
         throw new ModelError(`Expected target ${ mem.target }`);
       if (target.kind !== 'entity') {
-        const isAssoc = this.csnUtils.getFinalBaseType(member.type) !== 'cds.Composition';
+        const isAssoc = this.csnUtils.getFinalBaseTypeWithProps(member.type)?.type !== 'cds.Composition';
         this.error(
           null,
           member.$path,

package/lib/checks/nonexpandableStructured.js

@@ -21,7 +21,7 @@ function nonexpandableStructuredInExpression(parent, name, expression) {
       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
+        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)');
         }

package/lib/checks/queryNoDbArtifacts.js

@@ -3,7 +3,8 @@
 const { hasAnnotationValue, isPersistedOnDatabase, isBuiltinType } = require('../model/csnUtils');
 /**
  * Make sure that all source artifacts and association targets reach the database
- * (otherwise the view can't be activated), but only if the source artifact is NOT activated against the database
+ * (otherwise the view can't be activated), but only if the source artifact is NOT activated against the database // <- what does this mean?
+ *
  * Check the given query for:
  * - Associations-traversal over skipped/abstract things
  * - Associations (indirectly) using managed associations without foreign keys

package/lib/checks/selectItems.js

@@ -1,33 +1,119 @@
 'use strict';
 
-const { forEachGeneric } = require('../model/csnUtils');
+const { forEachGeneric, applyTransformationsOnNonDictionary } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
- * Validate select items of a query.
+ * Validate select items of a query. If a column reference starts with $self or $projection, it must not contain association steps.
+ * Furthermore, for to.hdbcds, window functions are not allowed.
+ *
+ * For to.hdbcds-hdbcds, structures and managed associations are not allowed as they are not flattened - @see rejectManagedAssociationsAndStructuresForHdbcdsNames
  *
  * @param {CSN.Query} query query object
+ * @todo Why do we care about this with $self?
  */
 function validateSelectItems(query) {
   const { SELECT } = query;
   if (!SELECT)
     return;
+  /**
+   * Check for a $self.<assoc> in columns etc. - since the $self.<assoc> references the "outside" view
+   * of the association, this is not allowed.
+   *
+   * @param {string} queryPart Part of the query that is being checked
+   * @returns {Function} Function as callback for applyTransformations
+   */
+  function checkRefForInvalid$Self(queryPart) {
+    const signalError = (error, parent, type) => {
+      if (queryPart === 'columns') {
+        error(null, parent.$path,
+              { name: parent.ref[0], type },
+              'Select items starting with $(NAME) must not contain path steps of type $(TYPE)');
+      }
+      else if (queryPart === 'orderBy') {
+        error(null, parent.$path,
+              { id: queryPart, type },
+              'Items of the $(ID)-clause must not contain path steps of type $(TYPE)');
+      }
+      else {
+        error(null, parent.$path,
+              { id: queryPart, name: parent.ref[0], type },
+              'Items of the $(ID)-clause starting with $(NAME) must not contain path steps of type $(TYPE)');
+      }
+    };
+    return function checkForInvalid$SelfInRef(parent) {
+      if (parent.ref && (parent.$scope === '$self' || parent.$scope === '$query')) {
+        const { _links } = parent;
+        for (let j = parent.$scope === '$self' ? 1 : 0; j < _links.length - 1; j++) {
+          if (_links[j].art.target) {
+            if (_links[j].art.on) {
+              // It's an unmanaged association - traversal is always forbidden
+              signalError(this.error, parent, _links[j].art.type);
+            }
+            else {
+              // It's a managed association - access of the foreign keys is allowed
+              const nextRef = parent.ref[j + 1].id || parent.ref[j + 1];
+              if (!_links[j].art.keys.some(r => r.ref[0] === nextRef))
+                signalError(this.error, parent, _links[j].art.type);
+            }
+          }
+        }
+
+        const last = _links[_links.length - 1];
+
+        if (last.art.target && last.art.on) {
+          // It's an unmanaged association - traversal is always forbidden
+          signalError(this.error, parent, last.art.type);
+        } // managed is okay, can be handled via tuple expansion
+      }
+    };
+  }
 
-  forEachGeneric(SELECT, 'columns', (selectItem) => {
-    if (selectItem.ref && (selectItem.ref[0] === '$self' || selectItem.ref[0] === '$projection')) {
-      const pathStepWithTarget = selectItem._links.slice(1).find(link => link.art.target);
-      if (pathStepWithTarget) {
-        this.error(null, selectItem.$path,
-                   { name: selectItem.ref[0], type: pathStepWithTarget.art.type },
-                   'Select items starting with $(NAME) must not contain path steps of type $(TYPE)');
+  /**
+   * Check the given assoc filter for usage of $self - in an assoc-filter, you must only
+   * address things on the target side of the association, not from global scope.
+   *
+   * @param {object} parent
+   * @param {string} prop
+   * @param {Array} where
+   */
+  function checkFilterForInvalid$Self(parent, prop, where) {
+    where.forEach((whereStep) => {
+      if (whereStep.ref && ( whereStep.ref[0] === '$projection' || whereStep.ref[0] === '$self')) {
+        this.error('expr-where-unexpected-self', whereStep.$path,
+                   { name: whereStep.ref[0] },
+                   'Path steps inside of filters must not start with $(NAME)');
       }
-    }
-    else if (this.options.transformation === 'hdbcds' && selectItem.xpr && selectItem.func) {
-      this.error(null, selectItem.$path,
-                 'Window functions are not supported by SAP HANA CDS');
-    }
-  });
+    });
+  }
+
+  const aTCB = (parent, prop) => {
+    applyTransformationsOnNonDictionary(parent, prop, {
+      ref: checkRefForInvalid$Self(prop).bind(this),
+      where: checkFilterForInvalid$Self.bind(this),
+    }, { skipStandard: { on: true }, drillRef: true });
+  };
+
+  const transformers = {
+    columns: aTCB,
+    groupBy: aTCB,
+    orderBy: aTCB,
+    having: aTCB,
+    where: aTCB,
+  };
+
+  if (this.options.transformation === 'hdbcds') {
+    transformers.xpr = (parent) => {
+      if (parent.func) {
+        this.error(null, parent.$path,
+                   'Window functions are not supported by SAP HANA CDS');
+      }
+    };
+  }
+
+  applyTransformationsOnNonDictionary(query, 'SELECT', transformers );
+
   // .call() with 'this' to ensure we have access to the options
   rejectManagedAssociationsAndStructuresForHdbcdsNames.call(this, SELECT, SELECT.$path);
 }

package/lib/checks/types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getUtils, isBuiltinType, hasAnnotationValue } = require('../model/csnUtils');
+const { getUtils, hasAnnotationValue } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -55,7 +55,7 @@ function checkElementTypeDefinitionHasType(member, memberName, prop, path) {
 
   // should only happen with csn input, not in cdl
   if (!hasArtifactTypeInformation(member)) {
-    warnAboutMissingType(this.error, path, memberName, true);
+    errorAboutMissingType(this.error, path, memberName, true);
     return;
   }
 
@@ -96,7 +96,7 @@ function checkTypeDefinitionHasType(artifact, artifactName, prop, path) {
 
   // should only happen with csn input, not in cdl
   if (!hasArtifactTypeInformation(artifact)) {
-    warnAboutMissingType(this.error, path, artifactName);
+    errorAboutMissingType(this.error, path, artifactName);
     return;
   }
 
@@ -129,8 +129,8 @@ function checkTypeOfHasProperType(artOrElement, name, model, error, path, derive
   if (!artOrElement.type)
     return;
 
-  const { getFinalBaseType } = getUtils(model);
-  const typeOfType = getFinalBaseType(artOrElement.type, path);
+  const { getFinalBaseTypeWithProps } = getUtils(model);
+  const typeOfType = getFinalBaseTypeWithProps(artOrElement.type);
 
   if (typeOfType === null) {
     if (artOrElement.type.ref) {
@@ -158,7 +158,7 @@ function checkTypeOfHasProperType(artOrElement, name, model, error, path, derive
  * @param {string} name of the element or the artifact which is dubious
  * @param {boolean} isElement indicates whether we are dealing with an element or an artifact
  */
-function warnAboutMissingType(error, path, name, isElement = false) {
+function errorAboutMissingType(error, path, name, isElement = false) {
   error('check-proper-type', path, { art: name, '#': isElement ? 'elm' : 'std' }, {
     std: 'Dubious type $(ART) without type information',
     elm: 'Dubious element $(ART) without type information',
@@ -176,8 +176,7 @@ function warnAboutMissingType(error, path, name, isElement = false) {
  */
 function hasArtifactTypeInformation(artifact) {
   // When is what property set?
-  return isBuiltinType(artifact.type) || // => `Integer`
-    artifact.elements ||  // => `type A {}`
+  return artifact.elements ||  // => `type A {}`
     artifact.items ||     // => `type A : array of Integer`
     artifact.enum ||      // => `type A : Integer enum {}`, `type` also set
     artifact.target ||    // => `type A : Association to B;`

package/lib/checks/utils.js

@@ -31,7 +31,7 @@ function otherSideIsExpandableStructure(on, startIndex) {
   return false;
 
   /**
-   * Artifact is structured or a managed association/compoisition
+   * Artifact is structured or a managed association/composition
    *
    * @param {CSN.Artifact} art Artifact
    * @returns {boolean} True if expandable
@@ -49,7 +49,7 @@ function otherSideIsExpandableStructure(on, startIndex) {
  */
 function resolveArtifactType(art) {
   if (art && art.type && !isBuiltinType(art.type))
-    return this.getFinalBaseType(art);
+    return this.csnUtils.getFinalBaseTypeWithProps(art.type);
 
   return art;
 }

package/lib/checks/validator.js

@@ -32,7 +32,6 @@ const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
 const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
-const unknownMagic = require('./unknownMagic');
 const managedWithoutKeys = require('./managedWithoutKeys');
 const {
   checkSqlAnnotationOnArtifact,
@@ -62,7 +61,7 @@ const forHanaArtifactValidators
   checkSqlAnnotationOnArtifact,
 ];
 
-const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];
+const forHanaCsnValidators = [ nonexpandableStructuredInExpression ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */
@@ -103,8 +102,9 @@ const commonMemberValidators
   validateAssociationsInItems, checkForInvalidTarget,
   checkVirtualElement, checkElementTypeDefinitionHasType ];
 
+// TODO: checkManagedAssoc is a forEachMemberRecursively!
 const commonArtifactValidators = [ checkTypeDefinitionHasType, checkPrimaryKey, checkManagedAssoc ];
-
+// TODO: Does it make sense to run the on-condition check as part of a CSN validator?
 const commonQueryValidators = [ validateMixinOnCondition ];
 
 /**