@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/transform/forOdataNew.js

@@ -22,7 +22,7 @@ const { flattenCSN } = require('./odata/structureFlattener');
 const generateForeignKeys = require('./odata/generateForeignKeyElements');
 const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssociations');
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { attachPath } = require('./odata/attachPath');
 const enrichUniversalCsn = require('./universalCsnEnricher');
 
@@ -191,7 +191,11 @@ function transform4odataWithCsn(inputModel, options) {
   generateForeignKeys(csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember);
 
   // Apply default type facets as set by options
-  // Flatten on-conditions in unmanaged associations
+  // Flatten on-conditions in unmanaged associations 
+  /* FIXME (HJB): Is this comment still correct? processOnCond only strips $self
+                  We should not remove $self prefixes in structured OData to not
+                  interfer with path resolution 
+  */
   // This must be done before all the draft logic as all
   // composition targets are annotated with @odata.draft.enabled in this step
   forEachDefinition(csn, [ setDefaultTypeFacets, processOnCond ], { skipArtifact: isExternalServiceMember });
@@ -569,6 +573,9 @@ function transform4odataWithCsn(inputModel, options) {
   // CDXCORE-481
   // (4.5) If the member is an association whose target has @cds.odata.valuelist annotate it
   // with @Common.ValueList.viaAssociation.
+  /*
+    FIXME (HJB): Comment outdated: Anno propagation to FKs is done in EdmPreprocessor
+  */
   // This must be done before foreign keys are calculated and the annotations are propagated
   // to them. This will make sure that association and all its foreign keys are annotated with
   // Common.ValueList in the final EDM.

package/lib/transform/localized.js

@@ -698,6 +698,8 @@ function copyPersistenceAnnotations(target, source) {
  * @param {CSN.Options} options
  */
 function hasExistingLocalizationViews(csn, options) {
+  if (!csn || !csn.definitions)
+    return false;
   const firstLocalizedView = Object.keys(csn.definitions).find(isInLocalizedNamespace);
   if (firstLocalizedView) {
     const { info } = makeMessageFunction(csn, options);

package/lib/transform/odata/structuralPath.js

@@ -10,7 +10,7 @@ const structuralNodeHandlers = {
   returns: traverseTyped,
   on: traverseArray,
   keys: traverseArray,
-  ref: traverseRef,
+  ref: traverseArray,
   query: traverseTyped,
   SELECT: traverseTyped,
   SET: traverseTyped,
@@ -33,10 +33,6 @@ function structuralPath(csn, path) {
   return traverseDict(csn.definitions, path, 1, ['definitions']);
 }
 
-function traverseRef(obj, path, index, typeStack) {
-  return traverseArray(obj, path, index, typeStack);
-}
-
 function traverseArray(obj, path, index, typeStack) {
   if(!Array.isArray(obj)) return typeStack;
   const name = path[index];

package/lib/transform/transformUtilsNew.js

@@ -80,6 +80,14 @@ function getTransformers(model, options, pathDelimiter = '_') {
       else if(defStrLen5k)
         element.length = 5000;
     }
+    if (element.type === 'cds.Binary' && element.length === undefined) {
+      if(options.defaultBinaryLength) {
+        element.length = options.defaultBinaryLength;
+        setProp(element, '$default', true);
+      }
+      else if(defStrLen5k)
+        element.length = 5000;
+    }
   /*
     if (element.type === 'cds.Decimal' && element.precision === undefined && options.precision) {
       element.precision = options.precision;
@@ -343,6 +351,8 @@ function getTransformers(model, options, pathDelimiter = '_') {
 
   /**
    * Copy properties of the referenced type, but don't resolve to the final base type.
+   * 
+   * Do not copy the length if it was just set via the default-value.
    *
    * @param {any} node Node to copy to
    * @returns {void}
@@ -1084,16 +1094,16 @@ function getTransformers(model, options, pathDelimiter = '_') {
   function expandStructsInExpression(csn, options = {}) {
     applyTransformations(csn, {
       'on': (parent, name, on, path) => {
-        parent.on = expand(parent.on, path);
+        parent.on = expand(parent.on, path.concat(name));
       },
       'having': (parent, name, having, path) => {
-        parent.having = expand(parent.having, path);
+        parent.having = expand(parent.having, path.concat(name));
       },
       'where': (parent, name, where, path) => {
-        parent.where = expand(parent.where, path);
+        parent.where = expand(parent.where, path.concat(name));
       },
       'xpr': (parent, name, xpr, path) => {
-        parent.xpr = expand(parent.xpr, path);
+        parent.xpr = expand(parent.xpr, path.concat(name));
       }
     }, undefined, undefined, options);
 
@@ -1111,17 +1121,21 @@ function getTransformers(model, options, pathDelimiter = '_') {
         if(i < expr.length-2)
         {
           const [lhs, op, rhs] = expr.slice(i);
+
+          // we might have to ad-hoc resolve a ref, since handleExists is run before hand and generates new refs.
+          const lhsArt = lhs._art || lhs.ref && !lhs.$scope && inspectRef(location.concat(i)).art;
+          const rhsArt = rhs._art || rhs.ref && !rhs.$scope && inspectRef(location.concat(i+2)).art;
           // lhs & rhs must be expandable types (structures or managed associations)
-          if(lhs._art && rhs._art &&
+          if(lhsArt && rhsArt &&
              lhs.ref && rhs.ref &&
-             isExpandable(lhs._art) && isExpandable(rhs._art) &&
+             isExpandable(lhsArt) && isExpandable(rhsArt) &&
              ['=', '<', '>', '>=', '<=', '!=', '<>'].includes(op) &&
              !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs))) {
 
             // if path is scalar and no assoc or has no type (@Core.Computed) use original expression
             // only do the expansion on (managed) assocs and (items.)elements, array of check in ON cond is done elsewhere
-            const lhspaths = /*isScalarOrNoType(lhs._art) ? [ lhs ] : */ flattenPath({ _art: lhs._art, ref: lhs.ref }, false, true );
-            const rhspaths = /*isScalarOrNoType(rhs._art) ? [ rhs ] : */ flattenPath({ _art: rhs._art, ref: rhs.ref }, false, true );
+            const lhspaths = /*isScalarOrNoType(lhs._art) ? [ lhs ] : */ flattenPath({ _art: lhsArt, ref: lhs.ref }, false, true );
+            const rhspaths = /*isScalarOrNoType(rhs._art) ? [ rhs ] : */ flattenPath({ _art: rhsArt, ref: rhs.ref }, false, true );
 
             // mapping dict for lhs/rhs for mismatch check
             // strip lhs/rhs prefix from flattened paths to check remaining common trailing path

package/lib/transform/translateAssocsToJoins.js

@@ -1,12 +1,12 @@
 'use strict'
 
 const { setProp, forEachGeneric, forEachDefinition, isBetaEnabled } = require('../base/model');
-var { makeMessageFunction } = require('../base/messages');
+const { makeMessageFunction } = require('../base/messages');
 const { recompileX } = require('../compiler/index');
-var { linkToOrigin } = require('../compiler/shared');
+const { linkToOrigin, pathName } = require('../compiler/utils');
 const  {compactModel, compactExpr} = require('../json/to-csn');
 const { deduplicateMessages } = require('../base/messages');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 // Paths that start with an artifact of protected kind are special
 // either ignore them in QAT building or in path rewriting
 const internalArtifactKinds = ['builtin'/*, '$parameters'*/, 'param'];
@@ -179,7 +179,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       let joinTree = query.from;
       for(let tan in query.$tableAliases)
       {
-        if(!['$projection', '$self'].includes(tan)) // don't drive into $projection/$self tableAlias (yet)
+        if(query.$tableAliases[tan].kind !== '$self') // don't drive into $projection/$self tableAlias (yet)
         {
           let ta = query.$tableAliases[tan];
           joinTree = createJoinTree(env, joinTree, ta.$qat, 'left', '$qat', ta.$QA);
@@ -200,7 +200,7 @@ function translateAssocsToJoins(model, inputOptions = {})
   function createQAForFromClauseSubQuery(query, env)
   {
     for (let taName in query.$tableAliases) {
-      if (!['$self', '$projection'].includes(taName)) {
+      if (query.$tableAliases[taName].kind !== '$self') {
         let ta = query.$tableAliases[taName];
         if(!ta.$QA) {
           ta.$QA = createQA(env, ta._origin, taName, undefined);
@@ -241,14 +241,6 @@ function translateAssocsToJoins(model, inputOptions = {})
         {
           art.$QA = createQA(env, art.target._artifact, art.name.id );
           art.$QA.mixin = true;
-          /* Mark mixin definition to be _ignored:
-            - If the mixin is used, it is now resolved into a join => definition vaporizes
-            - If the mixin is published, forHana backend must create a __copy with rewritten
-              $projection ON conditon and publish it with alias.
-            - If the mixin is neither be used nor published it shall not be visible to the database
-              (internal mixin).
-          */
-          art.$a2j = { _ignore: true };
         }
       });
     }
@@ -317,7 +309,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       let [QA, ps] = rightMostQA(tail, head._navigation._parent.$QA || head._navigation.$QA);
       if(!QA) {
         error(null, pathNode.$location,
-          { name: pathNode.path.map(ps=ps.id).join('.') },
+          { name: pathName(pathNode.path) },
           'Please debug me: No QA found for generic path rewriting in $(NAME)')
         return;
       }
@@ -1403,7 +1395,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
     let [head, ...tail] = path;
 
-    if(['$projection', '$self'].includes(head.id) && tail.length) {
+    if(['$projection', '$self'].includes(head.id) && tail.length && head._navigation.kind === '$self') {
       // make sure not to truncate tail
       if(tail.length > 1)
         [head, ...tail] = tail;

package/lib/utils/file.js

@@ -3,6 +3,7 @@
 'use strict';
 
 const fs = require('fs');
+const util = require('util');
 
 /**
  * Split the given source string into its lines.  Respects Unix,
@@ -19,8 +20,8 @@ function splitLines(src) {
  * Returns filesystem utils readFile(), isFile(), realpath() for _CDS_ usage.
  * This includes a trace as well as usage of a file cache.
  *
- * Note: The synchronous versions accept a callback as well, which is executed
- *       immediately! This is different from NodeJS's readFileSync()!
+ * Note: The synchronous versions accept a callback instead of being async (duh!), which
+ *       is executed immediately! This is different from NodeJS's readFileSync()!
  *       This is done to allow using it in places where fs.readFile (async) is used.
  *
  * @param {object} fileCache
@@ -30,7 +31,7 @@ function cdsFs(fileCache, enableTrace) {
   const readFile = _wrapReadFileCached(fs.readFile);
   const readFileSync = _wrapReadFileCached((filename, enc, cb) => {
     try {
-      cb(null, fs.readFileSync( filename, enc ));
+      cb(null, fs.readFileSync( filename, { encoding: enc } ));
     }
     catch (err) {
       cb(err, null);
@@ -47,10 +48,13 @@ function cdsFs(fileCache, enableTrace) {
   });
 
   return {
+    readFileAsync: util.promisify(readFile),
     readFile,
     readFileSync,
+    isFileAsync: util.promisify(isFile),
     isFile,
     isFileSync,
+    realpathAsync: util.promisify(realpath),
     realpath,
     realpathSync,
   };
@@ -72,7 +76,7 @@ function cdsFs(fileCache, enableTrace) {
    * Wraps the given reader into a cached environment including a trace.
    * The given @p reader must have the same signature as fs.readFile.
    *
-   * @param {(filename: string, enc: string, cb: (err, data) => void) => void} reader
+   * @param {(filename: string, enc, cb: (err, data) => void) => void} reader
    */
   function _wrapReadFileCached( reader ) {
     return (filename, enc, cb) => {
@@ -93,7 +97,9 @@ function cdsFs(fileCache, enableTrace) {
           body.syscall = 'open';
           body.path = filename;
         }
-        if (body instanceof Error) {
+        if (body && body.stack && body.message) {
+          // NOTE: checks for instanceof Error are not reliable if error
+          //       created in different execution env
           traceFS( 'READFILE:cache-error:', filename, body.message );
           cb( body );   // no need for process.nextTick( cb, body ) with moduleResolve
         }

package/lib/utils/term.js

@@ -2,8 +2,8 @@
 // This file is used for color output to stderr and stdout.
 // Use `term.error`, `term.warn` and `term.info` as they use color output
 // per default if the process runs in a TTY, i.e. stdout as well as
-// stderr are TTYs. stderr/stdout are no TTYs if they (for example)
-// are piped to another process or written to file:
+// stderr are TTYs.  stderr/stdout are no TTYs if they are
+// (for example) piped into another process or written to file:
 //
 //    node myApp.js              # stdout.isTTY: true,      stderr.isTTY: true
 //    node myApp.js | cat        # stdout.isTTY: undefined, stderr.isTTY: true
@@ -17,23 +17,9 @@
 const stderrHasColor = process.stderr.isTTY;
 const stdoutHasColor = process.stdout.isTTY;
 
-let hasColor = stdoutHasColor && stderrHasColor;
-
-module.exports.useColor = (mode) => {
-  switch (mode) {
-    case false:
-    case 'never':
-      hasColor = false;
-      break;
-    case true:
-    case 'always':
-      hasColor = true;
-      break;
-    default:
-      hasColor = stdoutHasColor && stderrHasColor;
-      break;
-  }
-};
+// Note: We require both stderr and stdout to be TTYs, as we don't
+//       know (in our exported functions) where the text will end up.
+const hasColorShell = stdoutHasColor && stderrHasColor;
 
 // https://docs.microsoft.com/en-us/windows/console/console-virtual-terminal-sequences
 const t = {
@@ -47,29 +33,66 @@ const t = {
   cyan: '\x1b[36m', // Foreground Cyan
 };
 
-const as = (codes, o) => (hasColor ? (codes + o + t.reset) : (`${ o }`));
+function term(useColor = 'auto') {
+  let hasColor = hasColorShell;
+  changeColorMode(useColor);
 
-const asError = o => as(t.red + t.bold, o);
-const asWarning = o => as(t.yellow, o);
-const asInfo = o => as(t.green, o);
-const asHelp = o => as(t.cyan, o);
-module.exports.underline = o => as(t.underline, o);
-module.exports.bold = o => as(t.bold, o);
-
-module.exports.asSeverity = (severity, msg) => {
-  switch ((`${ severity }`).toLowerCase()) {
-    case 'error': return asError(msg);
-    case 'warning': return asWarning(msg);
-    case 'info': return asInfo(msg);
-    case 'help': return asHelp(msg);
-    // or e.g. 'none'
-    default: return msg;
+  function changeColorMode(mode) {
+    switch (mode) {
+      case false:
+      case 'never':
+        hasColor = false;
+        break;
+      case true:
+      case 'always':
+        hasColor = true;
+        break;
+      default:
+        // Note: See also: https://no-color.org/
+        //       > Command-line software which adds ANSI color to its output by default
+        //       > should check for the presence of a `NO_COLOR` environment variable
+        //       > that, when present (regardless of its value), prevents the addition
+        //       > of ANSI color.
+        // Note: To be able to disable colors in tests, we check the environment
+        //       variable here again.
+        hasColor = hasColorShell && (process.env.NO_COLOR === undefined);
+        break;
+    }
   }
-};
 
-module.exports.codes = t;
-module.exports.as = as;
-module.exports.error = asError;
-module.exports.warn = asWarning;
-module.exports.info = asInfo;
-module.exports.help = asHelp;
+  const as = (codes, o) => (hasColor ? (codes + o + t.reset) : (`${ o }`));
+
+  const asError = o => as(t.red + t.bold, o);
+  const asWarning = o => as(t.yellow, o);
+  const asInfo = o => as(t.green, o);
+  const asHelp = o => as(t.cyan, o);
+
+  const underline = o => as(t.underline, o);
+  const bold = o => as(t.bold, o);
+
+  const asSeverity = (severity, msg) => {
+    switch ((`${ severity }`).toLowerCase()) {
+      case 'error': return asError(msg);
+      case 'warning': return asWarning(msg);
+      case 'info': return asInfo(msg);
+      case 'help': return asHelp(msg);
+      // or e.g. 'none'
+      default: return msg;
+    }
+  };
+
+  return {
+    changeColorMode,
+    as,
+    underline,
+    bold,
+
+    severity: asSeverity,
+    error: asError,
+    warn: asWarning,
+    info: asInfo,
+    help: asHelp,
+  };
+}
+
+module.exports = { term };

package/lib/utils/timetrace.js

@@ -5,7 +5,7 @@
  *
  * @class TimeTrace
  */
-class TimeTrace {
+class StopWatch {
   /**
    * Creates an instance of TimeTrace.
    * @param {string} id
@@ -13,29 +13,46 @@ class TimeTrace {
    * @memberOf TimeTrace
    */
   constructor(id) {
-    let startTime;
-    /**
-     * Start measuring.
-     *
-     * @param {number} indent
-     */
-    this.start = function start(indent) {
-      // eslint-disable-next-line no-console
-      console.error(`${ ' '.repeat((indent) * 2) }${ id } started`);
-      startTime = process.hrtime();
-    };
+    this.id = id;
+    // eslint-disable-next-line no-multi-assign
+    this.startTime = this.lapTime = process.hrtime();
+  }
 
-    /**
-     * Stop measuring and log the result
-     *
-     * @param {number} indent
+  /**
+     * Start watch.
      */
-    this.stop = function stop(indent) {
-      const endTime = process.hrtime(startTime);
-      const base = `${ ' '.repeat(indent * 2) }${ id } took:`;
-      // eslint-disable-next-line no-console
-      console.error( `${ base }${ ' '.repeat(60 - base.length) } %ds %dms`, endTime[0], endTime[1] / 1000000);
-    };
+  start() {
+    // eslint-disable-next-line no-multi-assign
+    this.startTime = this.lapTime = process.hrtime();
+  }
+
+  /**
+   * Stop and return delta T
+   * but do not set start time
+   */
+  stop() {
+    return process.hrtime(this.startTime);
+  }
+
+  /**
+   * return lap time
+   */
+  lap() {
+    const dt = process.hrtime(this.lapTime);
+    this.lapTime = process.hrtime();
+    return dt;
+  }
+
+  // stop as sec.ns float
+  stopInFloatSecs() {
+    const dt = this.stop();
+    return dt[0] + dt[1] / 1000000000;
+  }
+
+  // lap as sec.ns float
+  lapInFloatSecs() {
+    const dt = this.lap();
+    return dt[0] + dt[1] / 1000000000;
   }
 }
 
@@ -67,9 +84,11 @@ class TimeTracer {
    */
   start(id) {
     try {
-      const b = new TimeTrace(id);
+      const b = new StopWatch(id);
       this.traceStack.push(b);
-      b.start(this.traceStack.length - 1);
+      b.start();
+      // eslint-disable-next-line no-console
+      console.error(`${ ' '.repeat((this.traceStack.length - 1) * 2) }${ id } started`);
     }
     catch (e) {
       // eslint-disable-next-line no-console
@@ -86,7 +105,10 @@ class TimeTracer {
   stop() {
     try {
       const current = this.traceStack.pop();
-      current.stop(this.traceStack.length);
+      const dT = current.stop();
+      const base = `${ ' '.repeat(this.traceStack.length * 2) }${ current.id } took:`;
+      // eslint-disable-next-line no-console
+      console.error( `${ base }${ ' '.repeat(60 - base.length) } %ds %dms`, dT[0], dT[1] / 1000000);
     }
     catch (e) {
       // eslint-disable-next-line no-console
@@ -101,4 +123,4 @@ const ignoreTimeTrace = {
 };
 
 const doTimeTrace = process && process.env && process.env.CDSC_TIMETRACING !== undefined;
-module.exports = doTimeTrace ? new TimeTracer() : ignoreTimeTrace;
+module.exports = { timetrace: (doTimeTrace ? new TimeTracer() : ignoreTimeTrace), StopWatch };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "2.10.2",
+  "version": "2.11.4",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",

package/lib/transform/db/helpers.js

@@ -1,58 +0,0 @@
-'use strict';
-
-/**
- * If a mixin association is published, return the mixin association.
- *
- * @param {CSN.Query} query Query of the artifact to check
- * @param {object} association Association (Element) published by the view
- * @param {string} associationName
- * @returns {object} The mixin association
- */
-function getMixinAssocOfQueryIfPublished(query, association, associationName) {
-  if (query && query.SELECT && query.SELECT.mixin) {
-    const aliasedColumnsMap = Object.create(null);
-    if (query.SELECT.columns) {
-      for (const column of query.SELECT.columns) {
-        if (column.as && column.ref && column.ref.length === 1)
-          aliasedColumnsMap[column.as] = column;
-      }
-    }
-
-    for (const elem of Object.keys(query.SELECT.mixin)) {
-      const mixinElement = query.SELECT.mixin[elem];
-      let originalName = associationName;
-      if (aliasedColumnsMap[associationName])
-        originalName = aliasedColumnsMap[associationName].ref[0];
-
-      if (elem === originalName)
-        return { mixinElement, mixinName: originalName };
-    }
-  }
-  return {};
-}
-
-/**
- * Check wether the given artifact uses the given mixin association.
- *
- * @param {CSN.Query} query Query of the artifact to check
- * @param {object} association Mixin association (Element) to check for
- * @param {string} associationName
- * @returns {boolean} True if used
- */
-function usesMixinAssociation(query, association, associationName) {
-  if (query && query.SELECT && query.SELECT.columns) {
-    for (const column of query.SELECT.columns) {
-      if (typeof column === 'object' && column.ref && column.ref.length > 1 && (column.ref[0] === associationName || column.ref[0].id === associationName)) {
-        // FIXME: This is not necessarily correct: the assoc name needs not be the first component, as e.g. $projection.assoc
-        // would be also valid. Check other paths like $self.assoc ....
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-module.exports = {
-  usesMixinAssociation,
-  getMixinAssocOfQueryIfPublished,
-};