@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/transform/universalCsnEnricher.js

@@ -1,67 +1,237 @@
 'use strict';
 
-const { forEachDefinition } = require('../base/model');
+const { setProp } = require('../base/model');
 const {
-  applyTransformations,
-  cloneCsn,
+  forEachDefinition,
+  forAllQueries,
   getUtils,
-  isBuiltinType,
+  forEachMember,
+  forEachMemberRecursively,
 } = require('../model/csnUtils');
 
 /**
- * Loop through a universal CSN and enrich it with the properties
+ * Loop through a universal CSN and enrich it with the properties/annotations
  * from the source definition - modifies the input model in-place
- * 
+ *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  */
-module.exports = function(csn, options) {
-  let { getOrigin, getFinalType, getFinalTypeDef } = getUtils(csn);
-  // User-defined structured types do not have the elements propagated any longer
-  // if there is no association among the elements. For that reason,
-  // as a first step propagate the elements of these
-  forEachDefinition(csn, (def) => {
-    if (def.kind === 'type' && def.type && !def.elements) {
-      const finalType = getFinalType(def.type);
-      if (isBuiltinType(finalType)) return;
-      const finalTypeDef = getFinalTypeDef(def.type);
-      if (finalTypeDef.elements)
-        def.elements = cloneCsn(finalTypeDef.elements, options);
+module.exports = function (csn, options) {
+  let { getOrigin, getQueryPrimarySource, artifactRef } = getUtils(csn);
+
+  // Properties on definition level that we treat specially.
+  // TODO: There might be more annotations that will need special treatment
+  // see lib/compiler/propagator.js for reference
+  const defProps = {
+    '@cds.autoexpose': onlyViaArtifact,
+    '@fiori.draft.enabled': onlyViaArtifact,
+    '@': (prop, target, source) => { target[prop] = source[prop] },
+    // Example: `type E : F;` does not have `elements`, but they are required for e.g. OData.
+    'elements': onlyTypeDef,
+  }
+
+  // In this first loop through the model, missing properties in universal CSN
+  // are propagated so the CSN can become client one
+  forEachDefinition(csn, propagate);
+
+  // The $origin properties need to be removed separately
+  // as the values are used in csnRef::getOrigin that is used during
+  // the propagation above.
+  // Currently testMode-only for comparison against client CSN.
+  if (options.testMode) removeDollarProperties(csn);
+
+  /**
+   * Identify the sources of the passed object and propagate the relevant
+   * properties/annotations.
+   *
+   * @param {Object} art Target object for propagation
+   */
+  function propagate(art) {
+    // check if art was already processed by the status flag
+    // TODO: clean up later on, together with validator clean up probably or
+    //       when this module is meant to be used standalone -> use internal cache to store already processed definitions?
+    if (art._status === 'propagated') return;
+
+    // collect chain of origins and propagate
+    // from the farthest to the nearest one to the target
+    let chain = [];
+    let target = art;
+    let origin = undefined;
+    do {
+      origin = getOrigin(target);
+      if (origin) {
+        chain.push({ target, origin });
+        target = origin;
+      }
+    } while (origin);
+
+    if (chain.length)
+      chain.reverse().forEach(propagateSingleStep);
+    else
+      // even if there weren't any found origin(s) on definition level
+      // we need to loop through the members
+      // TODO: construct use-/test-case where there might be the need that an origin chain
+      //       needs to be constructed for members as well, specifically for this 'else'
+      //       case where we do not run through the definitions
+      propagateMembersProps(target);
+
+    function propagateSingleStep({ target, origin }) {
+      // if target was already processed -> continue
+      if (target._status === 'propagated') return;
+      // propagate relevant definition level properties
+      // we check for kind as in the future the function should be
+      // generic and work for parts of CSN
+      if (target.kind) propagateDefProps(target, origin);
+      // propagate properties to members
+      propagateMembersProps(target);
+
+      setProp(target, '_status', 'propagated');
+    }
+
+    /**
+     * Propagate from 'source' to 'target' the relevant properties
+     * for CSN definitions.
+     *
+     * @param {CSN.Definition} target
+     * @param {CSN.Definition} source
+     */
+    function propagateDefProps(target, source) {
+      const keys = Object.keys(source);
+      for (const prop of keys) {
+        // do not overwrite properties in target def
+        if (!(prop in target)) {
+          const func = defProps[prop] || defProps[prop.charAt(0)];
+          if (func) func(prop, target, source);
+        }
+      }
+    }
+
+    /**
+     * Propagate properties from Universal to Client CSN relevant for members.
+     *
+     * @param {CSN.Artifact} target
+     */
+    function propagateMembersProps(target) {
+      // TODO: in the future, consider case when target is a member itself,
+      //       for when we do not run with the complete CSN
+      // TODO: use newly added 'forEachMemberRecursivelyWithQuery'
+      forEachMemberRecursively(target, (member) => {
+        propagateMemberPropsFromOrigin(member);
+        if (member.target && !member.keys && !member.on)
+          calculateForeignKeys(member);
+      });
+      target.query && forAllQueries(target.query, (query) => {
+        if (query.SELECT && query.SELECT.elements) {
+          forEachMember(query.SELECT, (member) => {
+            propagateMemberPropsFromOrigin(member);
+            if (member.target && !member.keys && !member.on)
+              calculateForeignKeys(member);
+          });
+        }
+      });
+      setProp(target, '_status', 'propagated');
     }
-  });
-
-  // as a second step, loop through all the $origin properties in the model
-  // and propagate the properties from the origin definition
-  applyTransformations(csn, {
-    '$origin': (node, _$orign, $originValue, _path, parent, propName) => {
-      if (!node.kind) { // we do not want to replace whole definitions
-        if (Array.isArray($originValue))
-          propagatePropsFromOrigin(node, propName, parent);
-        else if ($originValue.$origin && Array.isArray($originValue.$origin)) {
-          // cover the case of query entity elements where we have own and ihnerited attributes/annotations
-          propagatePropsFromOrigin($originValue, propName, parent);
+
+    function propagateMemberPropsFromOrigin(member) {
+      // For empty members (`{}`), the origin was set in a previous call to `getOrigin(definition)`.
+      const memberOrigin = getOrigin(member);
+      if (!memberOrigin) return;
+
+      // when having an element with a type property that is
+      // user-defined there is no need to propagate 'elements',
+      // 'kind', etc. from the origin (which is the type definition)
+      if (member.type && Object.keys(member).length === 1) return;
+
+      const keys = Object.keys(memberOrigin);
+      // Copy over properties from the origin element.
+      // Don't propagate "kind" as this property is not allowed in elements.
+      for (const key of keys) {
+        if (!(key in member) && key !== 'kind')
+          member[key] = memberOrigin[key];
+      }
+
+      // copy over own annotations/properties
+      // TODO: try to create use-/test-case where this needs
+      //       to be applied on definition level, ATM it is done only for members
+      if (member.$origin && !Array.isArray(member.$origin) && member.$origin.$origin) {
+        const ownKeys = Object.keys(member.$origin);
+        for (const key of ownKeys) {
+          if (key !== '$origin')
+            member[key] = member.$origin[key];
         }
+      }
 
+      // In case of managed composition an anonymous $origin is used.
+      // csnRefs::getOrigin returns {} for such a member, thus have to recreate the client CSN from
+      // the values in the $origin. PR #8072
+      if (!Object.keys(memberOrigin).length && member.$origin && member.$origin.type === 'cds.Composition') {
+        member.type = member.$origin.type;
+        member.cardinality = member.$origin.cardinality;
+        member.targetAspect = member.$origin.target;
       }
     }
-  }, undefined, undefined, options);
-
-  function propagatePropsFromOrigin(member, memberName, construct) {
-    // TODO: shall the $origin be kept as part of the element?
-    const origin = getOrigin(member);
-    if (origin.kind) return;
-    if (member.elements && origin.type) {
-      delete member.$origin;
-      member.type = origin.type;
-      return;
+
+    function calculateForeignKeys(member) {
+      // managed assocs in universal CSN have no longer keys
+      // if they are not explicitly defined - PR#8064
+      const target = artifactRef(member.target);
+      const targetKeys = Object.keys(target.elements).filter((key) => target.elements[key].key);
+      member.keys = targetKeys.map(
+        keyName => { return { ref: [keyName] } }
+      );
     }
-    let newMember = cloneCsn(origin, options);
-    // keep targets and keys of assoc, if it was redirected
-    if (origin.type === 'cds.Association') {
-      newMember.target = member.target || newMember.target;
-      newMember.keys = member.keys || newMember.keys;
+
+  }
+
+  /**
+   * @cds.autoexpose for example, is propagated only if at definition level and only if
+   * the primary source (left-most) does not follow an association.
+   *
+   * @param {String} prop
+   * @param {CSN.Definition} target
+   * @param {CSN.Definition} source
+   */
+  function onlyViaArtifact(prop, target, source) {
+    if (!target.kind) return;
+    const primarySourceRef = getQueryPrimarySource(target.query || target.projection);
+    const artRef = primarySourceRef ? artifactRef(primarySourceRef) : source;
+    if (!artRef.target) {
+      target[prop] = source[prop];
     }
-    // TODO: check if this works fine for items/returns/actions
-    construct[memberName] = newMember;
+  }
+
+  /**
+   * Execute only if the target definition is a user-defined type.
+   *
+   * @param {String} prop
+   * @param {CSN.Definition} target
+   * @param {CSN.Definition} source
+   * @returns
+   */
+  function onlyTypeDef(prop, target, source) {
+    if (target.kind !== 'type') return;
+    target[prop] = source[prop];
+  }
+
+  /**
+   * Removes every occurrence of '$origin' and '$generated'
+   * for compatibility with what we have in client CSN.
+   *
+   * @param {CSN.Model} csn
+   */
+  function removeDollarProperties(csn) {
+    forEachDefinition(csn, (def) => {
+      delete def.$origin;
+      delete def.$generated;
+      // TODO: use newly added 'forEachMemberRecursivelyWithQuery'
+      forEachMemberRecursively(def, (member) => delete member.$origin);
+      def.query && forAllQueries(def.query, (query) => {
+        if (query.SELECT && query.SELECT.elements) {
+          forEachMember(query.SELECT, (member) => {
+            delete member.$origin;
+          });
+        }
+      });
+    })
   }
 }

package/lib/utils/file.js

@@ -3,10 +3,11 @@
 'use strict';
 
 const fs = require('fs');
+const util = require('util');
 
 /**
  * Split the given source string into its lines.  Respects Unix,
- * Windows und Macintosh line breaks.
+ * Windows and Macintosh line breaks.
  *
  * @param {string} src
  * @returns {string[]}
@@ -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,14 @@ function cdsFs(fileCache, enableTrace) {
   });
 
   return {
+    /** @type {function(string, string)} */
+    readFileAsync: util.promisify(readFile),
     readFile,
     readFileSync,
+    isFileAsync: util.promisify(isFile),
     isFile,
     isFileSync,
+    realpathAsync: util.promisify(realpath),
     realpath,
     realpathSync,
   };
@@ -72,7 +77,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 +98,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

@@ -1,11 +1,11 @@
 'use strict';
 
 /**
- * A single TimeTrace encapsulates the runtime of a selected code frame.
+ * A single StopWatch encapsulates the runtime of a selected code frame.
  *
  * @class TimeTrace
  */
-class TimeTrace {
+class StopWatch {
   /**
    * Creates an instance of TimeTrace.
    * @param {string} id
@@ -13,29 +13,48 @@ 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;
+    // TODO: If we require Node 12, use process.hrtime.bigint()
+    //       as process.hrtime() is deprecated.
+    // 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 +86,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 +107,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 +125,8 @@ 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),
+  TimeTracer,
+  StopWatch,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "2.10.4",
+  "version": "2.12.0",
   "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,
-};