@sap/cds-compiler 4.0.0 → 4.1.2

package/lib/base/message-registry.js

@@ -52,6 +52,7 @@ const centralMessages = {
   'anno-unstable-array': { severity: 'Warning' },
   'anno-invalid-sql-element': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-struct': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
+  'anno-invalid-sql-assoc': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-calc': { severity: 'Error', configurableFor: true },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-kind': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
   'anno-invalid-sql-view': { severity: 'Error', configurableFor: true  },  // @sql.prepend/append - configurable for "I know what I'm doing"
@@ -63,46 +64,36 @@ const centralMessages = {
   'anno-undefined-param':   { severity: 'Warning' },
   'anno-unexpected-ellipsis': { severity: 'Error', configurableFor: 'deprecated' },
 
-  'args-expecting-named':  { severity: 'Error' },
-  'args-no-params':       { severity: 'Error' },
-  'args-undefined-param': { severity: 'Error' },
-
   'name-invalid-dollar-alias': { severity: 'Error', configurableFor: true },
 
   'type-invalid-items': { severity: 'Error' }, // not supported yet
   'assoc-as-type':  { severity: 'Error' }, // TODO: allow more, but not all
+  'def-unexpected-nested-proj': { severity: 'Error', configurableFor: 'v4' },
   'def-unexpected-paramview-assoc': { severity: 'Error' },
   'def-unexpected-calcview-assoc': { severity: 'Error' },
   'chained-array-of': { severity: 'Error' },
-  'check-proper-type':    { severity: 'Error', configurableFor: [ 'compile' ] },
+  'def-missing-type':    { severity: 'Error', configurableFor: [ 'compile' ] },
   'check-proper-type-of': { severity: 'Info',  errorFor: [ 'for.odata', 'to.edmx', 'to.hdbcds', 'to.sql', 'to.hdi', 'to.rename' ] },
 
   'def-duplicate-autoexposed': { severity: 'Error' },
   'def-unexpected-default': { severity: 'Error', configurableFor: 'test' },
 
-  'expr-no-filter': { severity: 'Error' },
+  'expr-unexpected-filter': { severity: 'Error' },
 
   'empty-type':   { severity: 'Info' }, // only still an error in old transformers
 
   'ref-deprecated-orderby': { severity: 'Error', configurableFor: true },
-  'ref-expecting-type': { severity: 'Error' },
-  'ref-sloppy-type': { severity: 'Error' },
+  'ref-invalid-type': { severity: 'Error' },
   'ref-unexpected-self': { severity: 'Error' },
-  'ref-expecting-bare-aspect': { severity: 'Error' },
+  'ref-invalid-include': { severity: 'Error' },
   'type-unexpected-typeof': { severity: 'Error' },
   'type-ignoring-argument': { severity: 'Error', configurableFor: true },
   'type-expected-builtin': { severity: 'Error', configurableFor: true },
   'type-expecting-service-target': { severity: 'Error', configurableFor: true },
-  'ref-expecting-action-param-type': { severity: 'Error' },
-  'ref-sloppy-actionparam-type': { severity: 'Error' },
-  'ref-expecting-event-type': { severity: 'Error' }, // TODO: Test coverage
-  'ref-sloppy-event-type': { severity: 'Error' },
-  'ref-expecting-struct': { severity: 'Error' },
   'ref-expecting-const': { severity: 'Error' },
-  'ref-expecting-entity': { severity: 'Error' },
-  'ref-expecting-source': { severity: 'Error' },
-  'ref-expecting-target': { severity: 'Error' },
-  'ref-sloppy-target': { severity: 'Warning' },
+  'ref-invalid-source': { severity: 'Error' },
+  'ref-invalid-target': { severity: 'Error' },
+  'ref-sloppy-target': { severity: 'Error', configurableFor: 'v4' },
 
   'extend-repeated-intralayer': { severity: 'Warning' },
   'extend-unrelated-layer':     { severity: 'Info' },
@@ -166,15 +157,13 @@ const centralMessages = {
   'syntax-unexpected-sql-clause': { severity: 'Error' }, // TODO: configurableFor:'tests'?
 
   'type-managed-composition': { severity: 'Error' },
-  'type-unsupported-precision-change': { severity: 'Error'},
+  'type-unsupported-precision-change': { severity: 'Error' },
+  'type-unsupported-key-change': { severity: 'Error', configurableFor: true },
 
   'def-missing-element': { severity: 'Error' },
 
   'def-unsupported-calc-elem': { severity: 'Error', configurableFor: true },
 
-  'unexpected-keys-for-composition': { severity: 'Error' }, // TODO: more than 30 chars
-  'unmanaged-as-key': { severity: 'Error' }, // is confusing
-  'composition-as-key': { severity: 'Error' }, // is confusing and not supported
   'def-invalid-key-cardinality': { severity: 'Error' },
   // Published! Used in @cap-js-community/odata-v2-adapter; if renamed, add to oldMessageIds
   'odata-spec-violation-array': { severity: 'Warning' }, // more than 30 chars
@@ -213,6 +202,8 @@ const oldMessageIds = createDict({
   'old-anno-duplicate': 'anno-duplicate', // Example
   'assoc-in-array': 'type-invalid-items',
   'duplicate-autoexposed': 'def-duplicate-autoexposed',
+  'expr-no-filter': 'expr-unexpected-filter',
+  'check-proper-type': 'def-missing-type',
 });
 
 // Set up the old-to-new message ID mapping in the message registry.
@@ -511,7 +502,12 @@ const centralMessageTexts = {
   // Messages for erroneous references -----------------------------------------
   // location at erroneous reference (if possible)
   'ref-deprecated-orderby': 'Replace source element reference $(ID) by $(NEWCODE); auto-corrected',
-  'ref-unexpected-self': 'Unexpected $(ID) reference; is valid only in ON-conditions',
+  'ref-unexpected-self': {
+    std: 'Unexpected $(ID) reference; is valid only in ON-conditions of unmanaged associations',
+    on: 'Unexpected $(ID) reference; is valid only if compared to be equal to an association of the target side',
+    subQuery: 'Unexpected $(ID) reference in a sub query',
+    setQuery: 'Unexpected $(ID) reference in a query on the right side of $(OP)',
+  },
   'ref-undefined-def': {
     std: 'Artifact $(ART) has not been found',
     // TODO: proposal 'No definition of $(NAME) found',
@@ -565,7 +561,11 @@ const centralMessageTexts = {
   },
   'ref-unexpected-assoc': {
     std: 'Unexpected reference to association $(NAME)', // "std" currently unused
+    unmanaged: 'Unexpected reference to an unmanaged association',
+    'self-unmanaged': 'Unexpected column reference starting with $(ALIAS) to an unmanaged association',
+    self: 'A reference to an unmanaged association is only valid when compared via $(CODE)',
     expr: 'Associations can\'t be used as values in expressions',
+    'expr-comp': 'Compositions can\'t be used as values in expressions',
     cast: 'Casting to an association is not supported',
   },
   'ref-unexpected-calculated': {
@@ -575,7 +575,7 @@ const centralMessageTexts = {
   },
   'ref-unexpected-localized': {
     std: 'Unexpected reference to localized element $(NAME)', // "std" currently unused
-    calc: 'Calculated elements can\'t refer to localized elements',
+    calc: 'Calculated elements "on-write" can\'t refer to localized elements',
   },
 
   'ref-unexpected-navigation': {
@@ -624,6 +624,14 @@ const centralMessageTexts = {
     comp: 'Unexpected composition inside $(PROP)',
   },
 
+  'type-unexpected-default': {
+    std: 'Unexpected $(KEYWORD) on an association/composition', // unused
+    multi: 'Unexpected $(KEYWORD); expected exactly one foreign key in combination with default value, but found $(COUNT)',
+    structured: 'Unexpected $(KEYWORD) in combination with structured foreign key $(NAME); $(KEYWORD) requires a non-structured foreign key',
+    'onCond': 'Unexpected $(KEYWORD) on an association/composition with ON-condition; $(KEYWORD) requires exactly one foreign key',
+    'targetAspect': 'Unexpected $(KEYWORD) on composition of aspect'
+  },
+
   'anno-builtin': 'Builtin types should not be annotated. Use custom type instead',
   'anno-undefined-def': 'Artifact $(ART) has not been found', // TODO: ext-
   'anno-undefined-art': 'No artifact has been found with name $(ART)',
@@ -654,14 +662,25 @@ const centralMessageTexts = {
     source: 'Unexpected definition of an association in an entity with parameters',
     target: 'Expected association target to have no parameters',
   },
+  'def-unexpected-nested-proj': {
+    std: 'Unexpected $(CODE)',
+    var: 'Unexpected $(CODE) after reference to CDS variable',
+    struct: 'Unexpected $(CODE); can only be used after a reference to a structure or association',
+    init: 'Unexpected $(CODE); can only be used after a reference to a structure, association or table alias',
+  },
   'def-unexpected-calcview-assoc': {
     std: 'unused',
     'source': 'Unexpected definition of an association in an entity annotated with $(ANNO)',
     'target': 'Expected association target not to be annotated with $(ANNO)',
   },
+  'def-invalid-key': {
+    std: 'The current element can\'t be defined as primary key', // (unused)
+    unmanaged: 'Unmanaged associations/compositions can\'t be defined as primary key',
+    composition: 'Managed aspect compositions can\'t be defined as primary key',
+  },
   'def-unexpected-key': {
     std: '$(ART) can\'t have additional keys',
-    virtual: 'Unexpected $(PROP) for virtual element $(NAME)',
+    virtual: 'Unexpected $(PROP) for virtual element $(ART)',
     // TODO: Better message?
     include: '$(ART) can\'t have additional keys (through include)',
   },
@@ -725,19 +744,27 @@ const centralMessageTexts = {
     missing: 'Expected element $(ID) to have at least all the same sub-elements as included artifacts, but it is missing $(NAME)'
   },
 
-  'ref-expecting-action-param-type': 'A type, an element, or a service entity is expected here',
-  'ref-expecting-const': 'A constant value is expected here',
-  'ref-expecting-event-type': 'A type, an element, an event, or a service entity is expected here',
-  'ref-expecting-entity': 'An entity, projection or view is expected here',
-  'ref-expecting-struct': 'A type, entity, aspect or event with direct elements is expected here',
-  'ref-expecting-type': 'A type or an element is expected here',
+  'ref-expecting-const': 'A constant expression or variable is expected here',
+  'ref-invalid-target': {
+    std: 'An entity, projection or view is expected here', // TODO: change text
+    composition: 'Expecting an entity or aspect as composition target',
+    bare: 'Expecting the target aspect to have elements',
+    aspect: 'Expecting the name of an aspect in property $(PROP)', // only CSN input
+  },
+  'ref-invalid-include': {
+    std: 'A type, entity, aspect or event with direct elements is expected here',
+    bare : 'An aspect without elements is expected here',
+  },
+  'ref-invalid-type': {
+    std: 'A type or an element is expected here',
+    param: 'A type, an element, or a service entity is expected here',
+    event: 'A type, an element, an event, or a service entity is expected here',
+  },
   // TODO: text variant if the association does not start an entity
-  'ref-expecting-source': 'A query source must be an entity or an association',
-  'ref-expecting-target': 'An entity or an aspect is expected here', // TODO: coverage
+  'ref-invalid-source': 'A query source must be an entity or an association',
   'extend-columns': 'Artifact $(ART) can\'t be extended with columns, only projections can',
   'extend-repeated-intralayer': 'Unstable element order due to repeated extensions in same layer',
   'extend-unexpected-include': 'Can\'t extend $(META) with includes',
-  'ref-expecting-bare-aspect': 'An aspect without elements is expected here',
 
   'ext-duplicate-same-file': 'Duplicate extension with $(PROP) in same file',
   'ext-duplicate-extend-type': 'Duplicate type extension for type $(TYPE)',
@@ -787,6 +814,8 @@ const centralMessageTexts = {
     target: 'Expected target $(TARGET) of specified element $(NAME) to be the same as the inferred element\'s target $(ART)',
     foreignKeys: 'Expected foreign keys of specified element $(NAME) to be the same as the inferred element\'s foreign keys',
     prop: 'Value for $(PROP) of the specified element $(NAME) does not match the inferred element\'s value',
+    enumExtra: 'Specified element $(NAME) differs from inferred element: it has an additional enum element $(ID)',
+    enumVal: 'Specified element $(NAME) differs from inferred element: it has a different value for enum element $(ID)',
   },
 
   'query-unexpected-property': {
@@ -794,10 +823,7 @@ const centralMessageTexts = {
     calculatedElement: 'Unexpected property $(PROP) in the specified element $(NAME); calculated elements are not supported in queries',
   },
 
-  'ref-sloppy-type': 'A type or an element is expected here',
-  'ref-sloppy-actionparam-type': 'A type, an element, or a service entity is expected here',
   'ref-sloppy-target': 'An entity or an aspect (not type) is expected here',
-  'ref-sloppy-event-type': 'A type, an element, an event, or a service entity is expected here',
 
   'ref-ambiguous': {
     std: 'Replace ambiguous $(ID) by $(NAMES)',
@@ -812,6 +838,16 @@ const centralMessageTexts = {
     entity: 'Entity $(ART) with managed compositions can\'t be used in types', // yet
   },
 
+  'type-unsupported-key-change': {
+    std: 'Added element $(ID) is a primary key change and will not work if the table contains data',
+    changed: 'Changed element $(ID) is a primary key change and will not work if the table contains data'
+  },
+
+  'type-unsupported-key-sqlite': {
+    std: 'Added element $(ID) is a primary key change and will not work with dialect $(NAME)',
+    changed: 'Changed element $(ID) is a primary key change and will not work with dialect $(NAME)'
+  },
+
   // -----------------------------------------------------------------------------------
   // Expressions
   // -----------------------------------------------------------------------------------
@@ -820,6 +856,16 @@ const centralMessageTexts = {
     std: 'Expected a comparison with $(OP) when using $(ID) in an ON-condition',
   },
 
+  'type-invalid-cardinality': {
+    std: 'Invalid value $(VALUE) for cardinality', // unused variant
+    sourceMax: 'Invalid value $(PROP) for maximum source cardinality, expecting a positive number or $(OTHERPROP)',
+    targetMax: 'Invalid value $(PROP) for maximum target cardinality, expecting a positive number or $(OTHERPROP)',
+    targetMin: 'Invalid value $(PROP) for minimum target cardinality, expecting a non-negative number',
+    sourceMin: 'Invalid value $(PROP) for minimum source cardinality, expecting a non-negative number',
+    sourceVal: 'Source minimum cardinality must not be greater than source maximum cardinality',
+    targetVal: 'Target minimum cardinality must not be greater than target maximum cardinality',
+  },
+
   'i18n-different-value': 'Different translation for key $(PROP) of language $(OTHERPROP) in unrelated layers',
 
   // OData version dependent messages
@@ -948,7 +994,7 @@ const centralMessageTexts = {
  *
  * @typedef {object} MessageConfig
  * @property {MessageSeverity} severity Default severity for the message.
- * @property {string[]|'deprecated'|'v4'|true} [configurableFor]
+ * @property {string[]|'deprecated'|'v4'|'test'|true} [configurableFor]
  *        Whether the error can be reclassified to a warning or lower.
  *        If not `true` then an array is expected with specified modules in which the error is downgradable.
  *        Only has an effect if default severity is 'Error'.

package/lib/base/messages.js

@@ -17,6 +17,7 @@ const { cdlNewLineRegEx } = require('../language/textUtils');
 const fs = require('fs');
 const path = require('path');
 const { inspect } = require('util')
+const { CsnLocation } = require('../compiler/classes');
 
 // term instance for messages
 const colorTerm = term();
@@ -94,7 +95,7 @@ class CompilationError extends Error {
     super( `CDS compilation failed\n${messages?.map( m => m.toString() ).join('\n') || ''}` );
     /** @since v4.0.0 */
     this.code = 'ERR_CDS_COMPILATION_FAILURE';
-    this.messages = messages;
+    this.messages = [ ...messages ].sort(compareMessageSeverityAware);
 
     // TODO: remove this bin/cdsc.js specifics
     Object.defineProperty( this, 'hasBeenReported', { value: false, configurable: true, writable: true, enumerable: false } );
@@ -128,7 +129,7 @@ class CompilationError extends Error {
 class CompileMessage {
   /**
    * Creates an instance of CompileMessage.
-   * @param {any} location Location of the message
+   * @param {CSN.Location} location Location of the message
    * @param {string} msg The message text
    * @param {MessageSeverity} [severity='Error'] Severity: Debug, Info, Warning, Error
    * @param {string} [id] The ID of the message - visible as property messageId
@@ -139,7 +140,7 @@ class CompileMessage {
    */
   constructor(location, msg, severity = 'Error', id = null, home = null, moduleName = null) {
     this.message = msg;
-    this.$location = { ...location, address: undefined };
+    this.$location = { __proto__: CsnLocation.prototype, ...location, address: undefined };
     this.validNames = null;
     this.home = home;  // semantic location, e.g. 'entity:"E"/element:"x"'
     this.severity = severity;
@@ -892,14 +893,14 @@ function replaceInString( text, params ) {
 }
 
 /**
- * @param {CSN.Location} loc
- * @returns {CSN.Location}
+ * @param {CsnLocation} loc
+ * @returns {CsnLocation}
  */
 function weakLocation( loc ) {
   if (!loc)
-    return {};
+    return new CsnLocation();
   // no endLine/endCol
-  return { file: loc.file, line: loc.line, col: loc.col };
+  return new CsnLocation( loc.file, loc.line, loc.col, undefined, undefined );
 }
 
 /**
@@ -1310,14 +1311,14 @@ function artName( art, omit ) {
   const r = (name.absolute) ? [ quoted( name.absolute ) ] : [];
   if (name.select && name.select > 1 || name.select != null && art.kind !== 'element') // Yes, omit select:1 for element - TODO: re-check
     r.push( (art.kind === 'extend' ? 'block:' : 'query:') + name.select ); // TODO: rename to 'select:1' and consider whether there are more selects
-  if (name.action && omit !== 'action')
+  if (name.action != null && omit !== 'action')
     r.push( `${ memberActionName(art) }:${ quoted( name.action ) }` );
-  if (name.alias && art.kind !== '$self' && name.$inferred !== '$internal')
+  if (name.alias != null && art.kind !== '$self' && name.$inferred !== '$internal')
     r.push( (art.kind === 'mixin' ? 'mixin:' : 'alias:') + quoted( name.alias ) );
   if (name.param != null && omit !== 'param')
     r.push( name.param ? `param:${ quoted( name.param ) }` : 'returns' ); // TODO: join
 
-  if (name.element && omit !== 'element') {
+  if (name.element != null && omit !== 'element') {
     if (name.select != null && !art.$inferred)
       r.push( 'column:' + quoted( name.element ) );
     else

package/lib/base/model.js

@@ -1,3 +1,8 @@
+// module- and csn/XSN-independent definitions
+
+// TODO: move XSN-specific things to lib/compiler/utils/
+// TODO: move CSN-specific things to ???
+
 'use strict';
 
 const { forEach } = require('../utils/objectUtils');
@@ -22,14 +27,13 @@ const queryOps = {
 const availableBetaFlags = {
   // enabled by --beta-mode
   annotationExpressions: true,
-  toRename: true, // Removes once it's publicly documented
   assocsWithParams: true, // beta, because runtimes don't support it, yet.
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
   enableUniversalCsn: true,
-  aspectWithoutElements: true, // TODO: do not just remove beta flag - remove elements, too!
   odataTerms: true,
   optionalActionFunctionParameters: true, // not supported by runtime, yet.
+  associationDefault: true,
   // disabled by --beta-mode
   nestedServices: false,
 };

package/lib/checks/defaultValues.js

@@ -53,12 +53,12 @@ function rejectParamDefaultsInHanaCds( member, memberName, prop, path ) {
  */
 function warnAboutDefaultOnAssociationForHanaCds( member, memberName, prop, path ) {
   const art = this.csn.definitions[path[1]];
-  if (!art.query && !art.projection && 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',
-                 });
+  if (this.options.transformation === 'hdbcds' && !art.query && !art.projection && member.target && member.default) {
+    const type = member._type?.type || member.type || 'cds.Association';
+    this.warning('type-invalid-default', path, { '#': type === 'cds.Association' ? 'std' : 'comp' }, {
+      std: 'Default on associations is not supported for HDBCDS',
+      comp: 'Default on compositions is not supported for HDBCDS',
+    });
   }
 }
 

package/lib/checks/foreignKeys.js

@@ -16,8 +16,6 @@ const { setProp } = require('../base/model');
 function validateForeignKeys( member, memberName ) {
   // We have a managed association
   const isManagedAssoc = mem => mem && mem.target && !mem.on;
-  // We have an unmanaged association
-  const isUnmanagedAssoc = mem => mem && mem.target && mem.on && !mem.keys;
 
   // Declared as arrow-function to keep scope the same (this value)
   const handleAssociation = (mem) => {
@@ -46,9 +44,6 @@ function validateForeignKeys( member, memberName ) {
     if (mem.items) {
       this.error(null, member.$path, {}, 'Array-like properties must not be foreign keys');
     }
-    else if (isUnmanagedAssoc(mem)) {
-      this.error(null, member.$path, {}, 'Unmanaged association must not be a foreign key');
-    }
     else if (mem.keys) {
       handleAssociation(mem);
     }

package/lib/checks/onConditions.js

@@ -2,6 +2,7 @@
 
 const { forEachGeneric } = require('../model/csnUtils');
 const { otherSideIsExpandableStructure, resolveArtifactType } = require('./utils');
+const { pathId } = require('../model/csnRefs');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -93,7 +94,7 @@ function validateOnCondition( member, memberName, property, path ) {
             }
             else {
               // It's a managed association - access of the foreign keys is allowed
-              checkForeignKeyAccess(member.on[i], j, csnPath, (errorIndex) => {
+              requireForeignKeyAccess(member.on[i], j, (errorIndex) => {
                 this.error('ref-unexpected-navigation', csnPath, {
                   '#': 'std', id, elemref, name: ref[errorIndex].id || ref[errorIndex],
                 });
@@ -158,22 +159,26 @@ function validateOnCondition( member, memberName, property, path ) {
 
 /**
  * Ensure that only foreign keys of the association `parent.ref[refIndex]` are accessed in `parent.ref`.
- * If a non-fk field is accessed, `callback` is invoked.
+ * If a non-fk field is accessed, `noForeignKeyCallback` is invoked.
  *
- * @param {object} parent Object containing `ref` and `_links` from csnRefs.
- * @param {number} refIndex Index of the to-be-checked association in `parent.ref`
- * @param {CSN.Path} csnPath
- * @param {(errorIndex: number) => void} callback Called if there are non-fk path steps. Argument is index in
- *          `parent.ref` that is faulty.  If a fk-step is missing, `errorIndex` will be `> parent.ref.length`.
+ * @param {object} parent
+ *     Object containing `ref` and `_links` from csnRefs.
+ *
+ * @param {number} refIndex
+ *     Index of the to-be-checked association in `parent.ref`
+ *
+ * @param {(errorIndex: number) => void} noForeignKeyCallback
+ *     Called if there are non-fk path steps.  Argument is index in `parent.ref` that is faulty.
+ *     If a fk-step is missing, `errorIndex` will be `> parent.ref.length`.
  */
-function checkForeignKeyAccess( parent, refIndex, csnPath, callback ) {
+function requireForeignKeyAccess( parent, refIndex, noForeignKeyCallback ) {
   const { ref, _links } = parent;
   const assoc = _links[refIndex].art;
 
-  const next = ref[refIndex + 1].id || ref[refIndex + 1];
+  const next = pathId(ref[refIndex + 1]);
   let possibleKeys = next && assoc.keys.filter(r => r.ref[0] === next);
   if (!possibleKeys || possibleKeys.length === 0) {
-    callback(refIndex + 1);
+    noForeignKeyCallback(refIndex + 1);
   }
   else {
     // For cases where `Association to T { struct.one, struct.two };` is used instead of `{ struct }`.
@@ -195,7 +200,7 @@ function checkForeignKeyAccess( parent, refIndex, csnPath, callback ) {
       ++fkIndex;
     }
     if (!success)
-      callback(refIndex + fkIndex);
+      noForeignKeyCallback(refIndex + fkIndex);
   }
 }
 
@@ -211,4 +216,4 @@ function validateMixinOnCondition( query, path ) {
     forEachGeneric( query.SELECT, 'mixin', validateOnCondition.bind(this), path );
 }
 
-module.exports = { validateOnCondition, validateMixinOnCondition, checkForeignKeyAccess };
+module.exports = { validateOnCondition, validateMixinOnCondition, requireForeignKeyAccess };