@sap/cds-compiler 2.11.2 → 2.11.4

package/lib/language/language.g4

@@ -1501,7 +1501,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         ':' // with element, e.g. `type T : E:elem enum { ... }`
@@ -1513,7 +1514,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         { this.docComment( $annos ); }
@@ -1522,7 +1524,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         // TODO: complain if used in anno def?

package/lib/main.d.ts

@@ -157,6 +157,84 @@ declare namespace compiler {
     serviceNames?: string[]
   }
 
+  /**
+   * Options used by SQL `to.sql()` backend.
+   *
+   * @see to.sql()
+   */
+  export interface SqlOptions extends Options {
+    /**
+     * The SQL naming mode decides how names are represented.
+     * Among others, this includes whether identifiers are quoted or not (note
+     * that "smart quoting" is handled by `sqlDialect`).
+     *
+     * - `plain`:
+     *   In this naming mode, dots are replaced by underscores.
+     *   Names are neither upper-cased nor quoted, unless "smart-quoting" is used.
+     *   This mode can be used with all SQL dialects.
+     * - `quoted`:
+     *   In this mode, all identifiers are quoted.  Dots are not replaced in table
+     *   and view names but are still replaced by underscores in element names.
+     *   This mode can only be used with SQL dialect `hana`.
+     * - `hdbcds`:
+     *   This mode uses names that are compatible to SAP HANA CDS.
+     *   In this mode, all identifiers are quoted.  Dots are neither replaced in table
+     *   nor element names.  Namespace identifiers are separated from the remaining
+     *   identifier by `::`, i.e. the dot is replaced.  For example `Ns.Books`
+     *   becomes `"Ns::Books"`.
+     *   This mode can only be used with SQL dialect `hana`.
+     *
+     * @default 'plain'
+     */
+    sqlMapping?: string | 'plain' | 'quoted' | 'hdbcds'
+    /**
+     * Use this option to specify what dialect of SQL you want.
+     *
+     * Different databases may support different feature sets of SQL.
+     * For example, timestamps are handled differently.  Furthermore, "smart-quoting"
+     * is enabled for `sqlite` and `hana`.  This is useful if identifiers
+     * collide with reserved keywords.
+     *
+     * - `plain`:
+     *   Use this option for best compatibility with standard SQL.
+     *   Note that "smart-quoting" is not available for this mode.
+     *   Requires `sqlMapping: 'plain'`.
+     * - `sqlite`:
+     *   This SQL dialect ensures compatibility with SQLite, which may not support
+     *   all SQL features used in your CDS files.  For example, `$at.from`/`$at.to` are
+     *   handled differently to ensure correctness for SQLite.  "smart-quoting"
+     *   quotes identifiers that are reserved keywords, but does not upper-case them.
+     *   Requires `sqlMapping: 'plain'`.
+     * - `hana`:
+     *   Use this SQL dialect for best compatibility with SAP HANA.
+     *   "smart-quoting" upper-cases and quotes identifiers.
+     *
+     * @default 'plain'
+     */
+    sqlDialect?: string | 'plain' | 'sqlite' | 'hana'
+    /**
+     * Object containing magic variables.  These magic variables are
+     * used as placeholder values.
+     *
+     * @since 2.11.0
+     */
+    variableReplacements?: {
+      [option: string]: string | object,
+      /**
+       * Commonly used placeholders for user's name and locale.
+       */
+      $user?: {
+        [option: string]: string | object,
+        id?: string
+        locale?: string
+      },
+      /**
+       * Commonly used placeholders for session variables.
+       */
+      $session?: Record<string, string | object>
+    }
+  }
+
   /**
    * The compiler's package version.
    * For more details on versioning and SemVer, see `doc/Versioning.md`
@@ -440,7 +518,7 @@ declare namespace compiler {
 
   export namespace to {
       function cdl(csn: CSN, options: Options): object;
-      function sql(csn: CSN, options: Options): any;
+      function sql(csn: CSN, options: SqlOptions): any;
 
       function edm(csn: CSN, options: ODataOptions): any;
       namespace edm {

package/lib/model/csnRefs.js

@@ -343,11 +343,18 @@ function csnRefs( csn ) {
     // }
     // if (origin)
     //   cached( art, '$origin', _a => setImplicitOrigin( art, origin ) );
-    return (art.elements || art.enum || (art.targetAspect || art.target).elements)[elem];
+    // console.log(art)
+    return (art.elements || art.enum || targetAspect( art ).elements)[elem];
+  }
+
+  function targetAspect( art ) {
+    const { $origin } = art;
+    return art.targetAspect ||
+      $origin && typeof $origin === 'object' && !Array.isArray( $origin ) && $origin.target ||
+      art.target;
   }
 
   // From the current CSN object, set implicit origin for the next navigation step
-  // Currently (TODO: ?) `elements` only, i.e. what is needed for name resolution.
   function setImplicitOrigin( art, origin ) {
     setMembersImplicit( art.actions, origin.actions );
     setMembersImplicit( art.params, origin.params );
@@ -480,7 +487,7 @@ function csnRefs( csn ) {
       // not selecting the corresponding element for a select column works,
       // because explicit keys can only be provided with explicit redirection
       // target
-      const target = csn.definitions[parent.target || parent.cast.target];
+      const target = csn.definitions[parent.target || parent.$origin && parent.$origin.target || parent.cast.target];
       return resolvePath( path, target.elements[head], 'target' );
     }
     if (baseEnv)                // ref-target (filter condition), expand, inline
@@ -593,7 +600,7 @@ function csnRefs( csn ) {
   function getQueryCache( parentQuery ) {
     if (!parentQuery)
       return { $aliases: Object.create(null) };
-    const pcache = cache.get( parentQuery );
+    const pcache = cache.get( parentQuery.projection || parentQuery );
     if (!parentQuery.SET)       // SELECT / projection: real sub query
       return { $aliases: Object.create(null), $next: pcache };
     // the parent query is a SET: that is not a sub query

package/lib/model/csnUtils.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const { setProp } = require('../base/model');
 const { csnRefs } = require('../model/csnRefs');
+const { applyTransformations, applyTransformationsOnNonDictionary } = require('../transform/db/applyTransformations');
 const { isBuiltinType } = require('../compiler/builtins.js')
 const { sortCsn, cloneCsnDictionary: _cloneCsnDictionary } = require('../json/to-csn');
 const version = require('../../package.json').version;
@@ -1053,112 +1053,6 @@ function getElementDatabaseNameOf(elemName, namingConvention) {
   }
 }
 
-
-/**
- * Loop through the model, applying the custom transformations on the node's matching.
- *
- * Each transformer gets:
- * - the parent having the property
- * - the name of the property
- * - the value of the property
- * - the path to the property
- *
- * @param {object} csn CSN to enrich in-place
- * @param {object} customTransformers Map of prop to transform and function to apply
- * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {Boolean} [skipIgnore=true] Wether to skip _ignore elements or not
- * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
- * @returns {object} CSN with transformations applied
- */
-function applyTransformations( csn, customTransformers={}, artifactTransformers=[], skipIgnore = true, options = {} ) {
-  const transformers = {
-    elements: dictionary,
-    definitions: dictionary,
-    actions: dictionary,
-    params: dictionary,
-    enum: dictionary,
-    mixin: dictionary,
-    ref: pathRef,
-    //type: simpleRef,
-    //target: simpleRef,
-    //includes: simpleRef,
-  }
-
-  const csnPath = [];
-  if (csn.definitions)
-    definitions( csn, 'definitions', csn.definitions );
-  return csn;
-
-  function standard( parent, prop, node ) {
-    if (!node || typeof node !== 'object' || !{}.propertyIsEnumerable.call( parent, prop ) || (typeof prop === 'string' && prop.startsWith('@')) || (skipIgnore && node._ignore))
-      return;
-
-    csnPath.push( prop );
-
-    if (Array.isArray(node)) {
-      node.forEach( (n, i) => standard( node, i, n ) );
-    }
-
-    else {
-      for (let name of Object.getOwnPropertyNames( node )) {
-        const trans = transformers[name] || standard;
-        if(customTransformers[name])
-          customTransformers[name](node, name, node[name], csnPath, parent, prop);
-
-        trans( node, name, node[name], csnPath );
-      }
-    }
-    csnPath.pop();
-  }
-
-  function dictionary( node, prop, dict ) {
-    // Allow skipping dicts like actions in forHanaNew
-    if(options.skipDict && options.skipDict[prop])
-      return;
-    csnPath.push( prop );
-    for (let name of Object.getOwnPropertyNames( dict )) {
-      standard( dict, name, dict[name] );
-    }
-    if (!Object.prototype.propertyIsEnumerable.call( node, prop ))
-      setProp(node, '$' + prop, dict);
-    csnPath.pop();
-  }
-
-  function definitions( node, prop, dict ) {
-    csnPath.push( prop );
-    for (let name of Object.getOwnPropertyNames( dict )) {
-      const skip = options && options.skipArtifact && options.skipArtifact(dict[name], name) || false;
-      if(!skip) {
-        artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
-        standard( dict, name, dict[name] );
-      }
-    }
-    if (!Object.prototype.propertyIsEnumerable.call( node, prop ))
-      setProp(node, '$' + prop, dict);
-    csnPath.pop();
-  }
-
-  //Keep looping through the pathRef
-  function pathRef( node, prop, path ) {
-    csnPath.push( prop );
-    path.forEach( function step( s, i ) {
-      if (s && typeof s === 'object') {
-        csnPath.push( i );
-        if(options.drillRef) {
-          standard(path, i, s);
-        } else {
-          if (s.args)
-            standard( s, 'args', s.args );
-          if (s.where)
-            standard( s, 'where', s.where );
-        }
-        csnPath.pop();
-      }
-    } );
-    csnPath.pop();
-  }
-}
-
 const _dependencies = Symbol('_dependencies');
 const _dependents = Symbol('_dependents');
 
@@ -1634,6 +1528,7 @@ module.exports = {
   getUnderscoredName,
   getElementDatabaseNameOf,
   applyTransformations,
+  applyTransformationsOnNonDictionary,
   setDependencies,
   isPersistedOnDatabase,
   generatedByCompilerVersion,

package/lib/model/enrichCsn.js

@@ -14,16 +14,22 @@
 // Other enumerable properties in the JSON for non-enumerable properties in the
 // original CSN:
 
-// * `$env` for the non-enumerable `$env` property in the original CSN.
-// * `$elements` for a non-enumerable `elements` property for sub queries.
+// * `$parens`: the number of parentheses provided by the user around an expression
+//   or query if the number is different to the usual (mostly 0, sometimes 1).
+// * `$elements` (in client-style CSN only) for a non-enumerable `elements` property
+//   for sub queries.
 
 // The following properties in the JSON represent the result of the CSN API
 // functions:
 
-// * `_type`, `_includes` and `_targets` have as values the `$locations` of the
+// * `_type`, `_includes` and `_targets` have as values the `$location`s of the
 //   referred artifacts which are returned by function `artifactRef`.
-// * `_links`, `_art` and `_scope` as sibling properties of `ref` have as values
-//   the `$locations` of the artifacts/members returned by function `inspectRef`.
+// * `_links` and `_art` as sibling properties of `ref` have as values the
+//   `$locations` of the artifacts/members returned by function `inspectRef`.
+// * `_scope` and `_env` as sibling properties of `ref` have (string) values,
+//   returned by function `inspectRef`, giving add/ info about the “ref base”.
+// * `_origin` (in Universal CSN only) has as value the `$location` of the
+//   prototype returned by function getOrigin().
 
 'use strict';
 
@@ -32,7 +38,6 @@ const { locationString } = require('../base/location');
 
 function enrichCsn( csn, options = {} ) {
   const transformers = {
-    // $env: reveal,
     elements: dictionary,
     definitions: dictionary,
     actions: dictionary,
@@ -84,7 +89,8 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function definition( parent, prop, obj ) {
-    const origin = getOrigin( obj ); // before standard for implicit protos inside
+    // call getOrigin() before standard() to set implicit protos inside standard():
+    const origin = handleError( err => err ? err.toString() : getOrigin( obj ) );
     standard( parent, prop, obj );
     if (obj.$origin === undefined && origin != null)
       obj._origin = refLocation( origin );
@@ -103,10 +109,10 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function refLocation( art ) {
-    if (art)
+    if (art && typeof art === 'object')
       return art.$location || '<no location>';
     if (!options.testMode)
-      return '<illegal link>';
+      return art || '<illegal link>';
     throw new Error( 'Undefined reference' );
   }
 
@@ -133,37 +139,19 @@ function enrichCsn( csn, options = {} ) {
   }
 
   function $origin( parent, prop, ref ) {
-    if (options.testMode) {
-      if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […], not $origin: {…}
+    handleError( err => {
+      if (err)
+        parent._origin = err.toString();
+      else if (Array.isArray( ref ) || typeof ref === 'string') // $origin: […], not $origin: {…}
         parent._origin = refLocation( getOrigin( parent, true ) );
       else if ( ref )
-        standard( parent, prop, ref )
-    }
-    else {
-      try {
-        if (Array.isArray( ref ) || typeof ref === 'string')  // $origin: […], not $origin: {…}
-          parent._origin = refLocation( getOrigin( parent, true ) );
-        else if ( ref )
-          standard( parent, prop, ref )
-      } catch (e) {
-        parent._origin = e.toString();
-      }
-    }
+        standard( parent, prop, ref );
+    } );
   }
 
   function pathRef( parent, prop, path ) {
-    const { links, art, scope, $env } = (() => {
-      if (options.testMode)
-        return inspectRef( csnPath );
-      else {
-        try {
-          return inspectRef( csnPath );
-        }
-        catch (e) {
-          return { scope: e.toString() };
-        }
-      }
-    } )();
+    const { links, art, scope, $env }
+          = handleError( err => (err) ? { scope: err.toString() } : inspectRef( csnPath ) );
     if (links)
       parent._links = links.map( l => refLocation( l.art ) );
     if (links && links[links.length-1].art !== art)
@@ -186,6 +174,16 @@ function enrichCsn( csn, options = {} ) {
     csnPath.pop();
   }
 
+  function handleError( callback ) {
+    if (options.testMode)
+      return callback();
+    try {
+      return callback();
+    } catch (err) {
+      return callback( err );
+    }
+  }
+
   function _cache_debug( obj, subCache ) {
     if (options.enrichCsn !== 'DEBUG')
       return;

package/lib/model/revealInternalProperties.js

@@ -271,12 +271,13 @@ function artifactIdentifier( node, parent ) {
     Object.defineProperty( node, '__unique_id__', { value: ++unique_id } );
   let outer = unique_id ? '##' + node.__unique_id__ : '';
   if (node._outer) {
-    outer = (node._outer.items === node) ? '/items'
-      : (node._outer.returns === node) ? '/returns' : '/returns/items';
+    if (node.$inferred === 'REDIRECTED')
+      outer = '/redirected';
+    else
+      outer = (node._outer.items === node) ? '/items'
+            : (node._outer.returns === node) ? '/returns' : '/returns/items';
     node = node._outer;
   }
-  else if (node.$inferred === 'REDIRECTED')
-    outer = '/redirected';
   if (node === parent)
     return 'this';
   if (node.kind === 'source')

package/lib/model/sortViews.js

@@ -79,7 +79,7 @@ function sortTopologically(csn, _dependents, _dependencies){
 /**
  * Sort the given sql statements so that they can be deployed sequentially.
  * For ordering, only the FROM clause of views is checked - this requires A2J to
- * be run beforehand to resovle association usages.
+ * be run beforehand to resolve association usages.
  *
  * @param {object} sql Map of <object name>: "CREATE STATEMENT"
  *
@@ -96,5 +96,12 @@ module.exports = function({sql, csn}){
   const result = [];
   // keep the "artifact name" - needed for to.hdi sorting
   layers.forEach(layer => layer.forEach(objName => result.push({name: objName, sql: sql[objName]})));
+  // attach sql artifacts which are not considered during the view sorting algorithm
+  // --> this is the case for "ALTER TABLE ADD CONSTRAINT" statements,
+  //     because their identifiers are not part of the csn.definitions
+  Object.entries(sql).forEach(([ name, sqlString ]) => {
+    if (!result.some( o => o.name === name )) // not in result but in incoming sql
+      result.push({ name, sql: sqlString })
+  });
   return result;
 }

package/lib/optionProcessor.js

@@ -31,6 +31,7 @@ optionProcessor
   .option('    --integrity-not-enforced')
   .option('    --assert-integrity <mode>', [ 'true', 'false', 'individual' ])
   .option('    --assert-integrity-type <type>', [ 'RT', 'DB' ])
+  .option('    --constraints-as-alter <boolean>')
   .option('    --deprecated <list>')
   .option('    --hana-flavor')
   .option('    --direct-backend')
@@ -110,7 +111,10 @@ optionProcessor
        --assert-integrity-type <type>  Specifies how the referential integrity checks should be performed:
                                            RT : (default) No database constraint for an association
                                                if not explicitly demanded via annotation
-                                           DB : Create database constraints for associations 
+                                           DB : Create database constraints for associations
+       --constraints-as-alter <boolean>  If set to 'true', the foreign key constraints will be rendered as 
+                                         "ALTER TABLE ADD CONSTRAINT" statement rather than being part of the
+                                         "CREATE TABLE" statement
        --deprecated <list>  Comma separated list of deprecated options.
                             Valid values are:
                               noElementsExpansion

package/lib/render/.eslintrc.json

@@ -13,8 +13,7 @@
     // Who cares - just very whiny and in the way
     "complexity": "off",
     "max-len": "off",
-    // We should enable this
-    "no-shadow": "off"
+    "no-shadow": "warn"
   },
   "env": {
     "es6": true

package/lib/render/toHdbcds.js

@@ -926,7 +926,7 @@ function toHdbcdsSource(csn, options) {
    */
   function renderParameter(parName, par, env) {
     if (par.notNull === true || par.notNull === false)
-      info(null, env.path.concat([ 'params', parName ]), 'Not Null constraints on HDBCDS view parameters are not allowed and are ignored');
+      info('query-ignoring-param-nullability', env.path.concat([ 'params', parName ]), { '#': 'std' });
     return `${env.indent + formatParamIdentifier(parName, env.path.concat([ 'params', parName ]))} : ${renderTypeReference(par, env)}`;
   }
 
@@ -1268,7 +1268,7 @@ function toHdbcdsSource(csn, options) {
         // (see FIXME at renderArtifact)
         if (idx === 0 && s === $SELF) {
           // do not produce USING for $projection
-          if (env.currentArtifactName === $PROJECTION && env._artifact && env._artifact.projection)
+          if (env.currentArtifactName === $PROJECTION)
             return env.currentArtifactName;
 
           return plainNames ? renderAbsoluteNamePlain(env.currentArtifactName, env)
@@ -1655,11 +1655,6 @@ function toHdbcdsSource(csn, options) {
     if (id.indexOf('.') !== -1)
       throw new Error(id);
 
-    // FIXME: Somewhat arbitrary magic: Do not quote $projection (because HANA CDS doesn't recognize it otherwise).  Similar for $self.
-    // FIXME: The test should not be on the name, but by checking the _artifact.
-    if (id === $PROJECTION || id === $SELF)
-      return id;
-
 
     switch (options.forHana.names) {
       case 'plain':

package/lib/render/toSql.js

@@ -19,6 +19,7 @@ const { timetrace } = require('../utils/timetrace');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { smartFuncId } = require('../sql-identifier');
 const { sortCsn } = require('../json/to-csn');
+const { manageConstraints } = require('./manageConstraints');
 
 
 /**
@@ -221,7 +222,6 @@ function toSqlDdl(csn, options) {
   for (const artifactName in csn.deletions)
     renderArtifactDeletionInto(artifactName, csn.deletions[artifactName], resultObj);
 
-
   // Render each artifact extension
   // Only HANA SQL is currently supported.
   // Note that extensions may contain new elements referenced in migrations, thus should be compiled first.
@@ -273,7 +273,6 @@ function toSqlDdl(csn, options) {
         // Hack: Other than in 'hdbtable' files, in HANA SQL COLUMN is not mandatory but default.
         if (options.toSql.dialect === 'hana' && hdbKind === 'hdbtable' && sourceString.startsWith('COLUMN '))
           sourceString = sourceString.slice('COLUMN '.length);
-
         sql[name] = `${options.testMode ? '' : sqlVersionLine}CREATE ${sourceString};`;
       }
       else if (!options.testMode) {
@@ -284,6 +283,15 @@ function toSqlDdl(csn, options) {
       delete resultObj[hdbKind];
   }
 
+  // add `ALTER TABLE ADD CONSTRAINT` statements if requested
+  if (options.sqlDialect !== 'sqlite' && options.constraintsAsAlter) {
+    const alterStmts = manageConstraints(csn, options);
+
+    for ( const constraintName of Object.keys(alterStmts))
+      sql[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
+    resultObj.sql = sql;
+  }
+
   if (options.toSql.src === 'sql')
     resultObj.sql = sql;
 
@@ -500,13 +508,9 @@ function toSqlDdl(csn, options) {
     result += `TABLE ${tableName}`;
     result += ' (\n';
     const elements = Object.keys(art.elements).map(eltName => renderElement(artifactName, eltName, art.elements[eltName], definitionsDuplicateChecker, getFzIndex(eltName, hanaTc), childEnv)).filter(s => s !== '').join(',\n');
-    if (elements !== '') {
+    if (elements !== '')
       result += elements;
-    }
-    else {
-      // TODO: Already be handled by 'empty-entity' reclassification; better location
-      error(null, [ 'definitions', artifactName ], 'Entities must have at least one element that is non-virtual');
-    }
+
     const uniqueFields = Object.keys(art.elements).filter(name => art.elements[name].unique && !art.elements[name].virtual)
       .map(name => quoteSqlId(name))
       .join(', ');
@@ -517,7 +521,8 @@ function toSqlDdl(csn, options) {
     if (primaryKeys !== '')
       result += `,\n${childEnv.indent}${primaryKeys}`;
 
-    if (art.$tableConstraints && art.$tableConstraints.referential) {
+    const constraintsAsAlter = options.constraintsAsAlter && options.sqlDialect !== 'sqlite';
+    if ( !constraintsAsAlter && art.$tableConstraints && art.$tableConstraints.referential) {
       const renderReferentialConstraintsAsHdbconstraint = options.toSql.src === 'hdi';
       const referentialConstraints = {};
       Object.entries(art.$tableConstraints.referential)
@@ -1087,7 +1092,7 @@ function toSqlDdl(csn, options) {
       for (const pn in params) {
         const p = params[pn];
         if (p.notNull === true || p.notNull === false)
-          info(null, [ 'definitions', artifactName, 'params', pn ], 'Not Null constraints on SQL view parameters are not allowed and are ignored');
+          info('query-ignoring-param-nullability', [ 'definitions', artifactName, 'params', pn ], { '#': 'sql' });
         // do not quote parameter identifiers for naming mode "quoted" / "hdbcds"
         // this would be an incompatible change, as non-uppercased, quoted identifiers
         // are rejected by the HANA compiler.
@@ -1500,7 +1505,7 @@ function toSqlDdl(csn, options) {
           return `'${options.toSql.user.id}'`;
 
         if (options.toSql.dialect === 'sqlite' || options.toSql.dialect === 'plain') {
-          warning(null, null, 'The "$user" variable is not supported. Use the "toSql.user" option to set a value for "$user.id"');
+          warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
           return '\'$user.id\'';
         }
         return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';