@sap/cds-compiler 3.0.0 → 3.1.2

package/lib/inspect/.eslintrc.json

@@ -0,0 +1,4 @@
+{
+  "root": true,
+  "extends": "../../.eslintrc-ydkjsi.json"
+}

package/lib/inspect/index.js

@@ -0,0 +1,14 @@
+// cds-compiler Inspect Module
+// Used by `cdsc inspect` to gather details about the model such as statistics, etc.
+
+'use strict';
+
+const { inspectModelStatistics } = require('./inspectModelStatistics');
+const { inspectPropagation } = require('./inspectPropagation');
+const { stringRefToPath } = require('./inspectUtils');
+
+module.exports = {
+  inspectModelStatistics,
+  inspectPropagation,
+  stringRefToPath,
+};

package/lib/inspect/inspectModelStatistics.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const { forEach } = require('../utils/objectUtils');
+const { term } = require('../utils/term');
+
+/**
+ * Return a string representation of the inspected results.
+ *
+ * @param {XSN.Model} xsn
+ * @param {CSN.Options} options
+ * @returns {string}
+ */
+function inspectModelStatistics(xsn, options) {
+  let result = '';
+
+  // Default color mode is 'auto'
+  const color = term(options.color || 'auto');
+
+  const defCount = countDefinitionKinds(xsn);
+  const sources = {
+    cdl: Object.keys(xsn.sources).filter(name => xsn.sources[name].$frontend === 'cdl').length,
+    csn: Object.keys(xsn.sources).filter(name => xsn.sources[name].$frontend === 'csn').length,
+  };
+
+  result += `cds-compiler model statistics:
+
+${ color.underline('files') }:         ${ Object.keys(xsn.sources).length }
+  cdl sources: ${ sources.cdl }
+  csn sources: ${ sources.csn }
+
+${ color.underline('definitions') }:  ${ defCount.definitions }
+  entities:   ${ defCount.entity }
+  queries:    ${ defCount.view }
+  aspects:    ${ defCount.aspect }
+  events:     ${ defCount.event }
+  types:      ${ defCount.type }
+  services:   ${ defCount.service }
+  context:    ${ defCount.context }
+  actions:    ${ defCount.action }
+  functions:  ${ defCount.function }
+  namespaces: ${ defCount.namespace } (explicitly in CDL)
+
+${ color.underline('vocabularies') }: ${ Object.keys(xsn.vocabularies || {}).length }
+`;
+  return result;
+}
+
+function countDefinitionKinds(xsn) {
+  const result = {
+    definitions: 0,
+    entity: 0,
+    action: 0,
+    function: 0,
+    aspect: 0,
+    event: 0,
+    type: 0,
+    service: 0,
+    context: 0,
+    namespace: 0,
+    // non-kind
+    view: 0,
+  };
+  forEach(xsn.definitions || {}, (name, def) => {
+    if (def.builtin)
+      return;
+    ++result.definitions;
+
+    if (def.query || def.projection)
+      ++result.view;
+    else if (result[def.kind] !== undefined)
+      ++result[def.kind];
+    else
+      throw new Error(`Unhandled kind: ${ def.kind } for ${ name }`);
+  });
+  return result;
+}
+
+
+module.exports = {
+  inspectModelStatistics,
+};

package/lib/inspect/inspectPropagation.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const { createMessageFunctions } = require('../base/messages');
+const { locationString } = require('../base/location');
+const { findArtifact, stringRefToPath } = require('./inspectUtils');
+const { term } = require('../utils/term');
+
+/**
+ * @param {XSN.Model} xsn
+ * @param {CSN.Options} options
+ * @param {string} artifactName
+ * @returns {string|null}
+ */
+function inspectPropagation(xsn, options, artifactName) {
+  const { error } = createMessageFunctions(options, 'inspect', xsn);
+  const result = [];
+
+  // Default color mode is 'auto'
+  const color = term(options.color || 'auto');
+
+  const path = stringRefToPath(artifactName);
+  if (!path) {
+    error(null, null, { name: artifactName },
+          'Artifact $(NAME) is not a valid path; expected format `<def>[:element]`');
+    return null;
+  }
+
+  const artifactXsn = findArtifact(xsn, path);
+
+  if (!artifactXsn) {
+    error(null, null, { name: artifactName },
+          // eslint-disable-next-line max-len
+          'Artifact $(NAME) not found, only top-level artifacts and their elements are supported for now');
+    return null;
+  }
+  result.push(color.underline('analyzing propagation for artifact:'));
+  result.push(`  name: ${ artifactXsn.name.id }`);
+  result.push(`  kind: ${ artifactXsn.kind }`);
+
+  if (artifactXsn.$inferred)
+    result.push(`  inferred: ${ artifactXsn.$inferred }`);
+
+  result.push('');
+  result.push(`  ${ color.underline('annotation propagation:') }`);
+  result.push(..._indent(_inspectAnnotations(artifactXsn)));
+
+  result.push('');
+  result.push(`  ${ color.underline('element propagation:') }`);
+  result.push(..._indent(_inspectElements(artifactXsn)));
+
+  return result.join('\n');
+}
+
+/**
+ @param {string[]} lines
+ @param {string} indent
+ * @returns {string[]}
+ */
+function _indent(lines, indent = '    ') {
+  return lines.map(str => `${ indent }${ str }`);
+}
+
+/**
+ * @param {XSN.Artifact} artifactXsn
+ * @returns {string[]}
+ * @private
+ */
+function _inspectAnnotations(artifactXsn) {
+  const result = [];
+  const annos = Object.keys(artifactXsn).filter(str => str.startsWith('@')).sort();
+
+  if (annos.length === 0)
+    return [ 'no annotations' ];
+
+  let maxAnnoLength = 30; // chosen arbitrarily, hopefully average
+  for (const anno of annos) {
+    const annoXsn = artifactXsn[anno];
+    const loc = locationString(annoXsn.name.location);
+    let origin;
+    switch (annoXsn.$priority) {
+      case false:
+        if (annoXsn.$inferred)
+          origin = 'propagation';
+        else
+          origin = 'direct';
+        break;
+
+      case 'extend':
+      case 'annotate':
+        origin = annoXsn.$priority;
+        break;
+
+      case undefined:
+        if (annoXsn.$inferred === '$generated') {
+          origin = 'generated';
+          break;
+        }
+        // fallthrough
+      default:
+        throw new Error(`inspect anno: Unhandled Case: ${ annoXsn.$priority }`);
+    }
+
+    maxAnnoLength = Math.max(maxAnnoLength, anno.length);
+
+    // origin: assume max length 11 of 'propagation'
+    // anno: use max length of all annotations till now
+    result.push([ origin.padStart(11), anno.padEnd(maxAnnoLength), loc ].join(' | '));
+  }
+  return result;
+}
+
+/**
+ * @param {XSN.Artifact} artifactXsn
+ * @returns {string[]}
+ * @private
+*/
+function _inspectElements(artifactXsn) {
+  if (!artifactXsn.elements)
+    return [ 'does not have elements' ];
+
+  const result = [];
+  const elements = Object.keys(artifactXsn.elements);
+
+  let maxElemLength = 12;
+
+  const inferredNiceOutput = {
+    '*': 'wildcard',
+    'expand-element': 'expanded',
+    'expand-param': 'expanded',
+    'aspect-composition': 'composition',
+  };
+
+  for (const element of elements) {
+    const elementXsn = artifactXsn.elements[element];
+    const loc = locationString(_origin(elementXsn).name.location);
+    let origin;
+
+    if (elementXsn.$inferred) {
+      // Use nice(r) output for known $inferred
+      if (inferredNiceOutput[elementXsn.$inferred])
+        origin = inferredNiceOutput[elementXsn.$inferred];
+      else
+        origin = elementXsn.$inferred;
+    }
+    else if (!isContainedInParentLocation(elementXsn, artifactXsn)) {
+      // just a heuristic
+      origin = 'extend';
+    }
+    else {
+      origin = 'direct';
+    }
+
+    maxElemLength = Math.max(maxElemLength, element.length);
+
+    // origin: assume max length 11 of 'composition'
+    // element: assume average length of 30, chosen randomly
+    result.push([ origin.padStart(11), element.padEnd(maxElemLength), loc ].join(' | '));
+  }
+  return result;
+}
+
+function _origin(elementXsn) {
+  while (elementXsn._origin)
+    elementXsn = elementXsn._origin;
+  return elementXsn;
+}
+
+/**
+ * Returns true if `art` is contained in `parent` according to its location.
+ *
+ * @param art
+ * @param parent
+ * @returns {boolean}
+ */
+function isContainedInParentLocation(art, parent) {
+  const artLoc = art.location;
+  const parentLoc = parent.location;
+  if (artLoc.file !== parentLoc.file)
+    return false;
+  if (artLoc.line < parentLoc.line || artLoc.line > parentLoc.endLine)
+    return false;
+  // Good enough for now
+  // TODO: Check columns
+  return true;
+}
+
+module.exports = {
+  inspectPropagation,
+};

package/lib/inspect/inspectUtils.js

@@ -0,0 +1,44 @@
+'use strict';
+
+/**
+ * Reference (string) to path (array) that can be used to identify an artifact
+ * @param str
+ * @returns {*[]|*}
+ */
+function stringRefToPath(str) {
+  // e.g. `ns.service.E:sub.elem.structured`
+  const path = str.split(':');
+  if (path.length === 1)
+    return path;
+  if (path.length > 2)
+    return null;
+  return [ path[0], ...path[1].split('.') ];
+}
+
+/**
+ * @param {XSN.Model} xsn
+ * @param {string} path
+ * @private
+ */
+function findArtifact(xsn, path) {
+  const segments = [ ...path ];
+  const topLevelName = segments[0];
+  let art = (xsn.definitions && xsn.definitions[topLevelName]) ||
+    (xsn.vocabularies && xsn.vocabularies[topLevelName]);
+  if (!art)
+    return null;
+  segments.shift();
+  if (segments.length === 0)
+    return art;
+  while (segments.length && art) {
+    const segment = segments.shift();
+    art = (art.items?.elements || art.elements)?.[segment];
+  }
+  return art || null;
+}
+
+
+module.exports = {
+  stringRefToPath,
+  findArtifact,
+};

package/lib/json/from-csn.js

@@ -88,6 +88,7 @@
  */
 
 const { dictAdd } = require('../base/dictionaries');
+const { quotedLiteralPatterns } = require('../compiler/builtins');
 
 const $location = Symbol.for('cds.$location');
 
@@ -102,6 +103,7 @@ const ourpropsRegex = /^[_$]?[a-zA-Z]+[0-9]*$/;
 const typeProperties = [
   // do not include CSN v0.1.0 properties here:
   'target', 'elements', 'enum', 'items',
+  'cardinality', // for association publishing in views
   'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
   'keys', 'on',                 // only with 'target'
 ];
@@ -227,7 +229,7 @@ const schema = compileSchema( {
     dictionaryOf: definition,
     defaultKind: 'action',
     validKinds: [ 'action', 'function' ],
-    inKind: [ 'entity', 'annotate', 'extend' ],
+    inKind: [ 'entity', 'aspect', 'annotate', 'extend' ],
   },
   params: {
     dictionaryOf: definition,
@@ -682,15 +684,6 @@ const topLevelSpec = {
   schema,
 };
 
-const validLiteralsExtra = Object.assign( Object.create(null), {
-  // TODO: should we use quotedLiteralPatterns from genericAntlrParser?
-  number: 'string',
-  x: 'string',
-  time: 'string',
-  date: 'string',
-  timestamp: 'string',
-} );
-
 // Module variables, schema compilation, and functors ------------------------
 
 /** @type {(id, location, textOrArguments, texts?) => void} */
@@ -1288,16 +1281,22 @@ function value( val, spec, xsn ) { // for CSN property 'val'
   return ignore( val );
 }
 
-function literal( val, spec, xsn, csn ) {
+function literal( lit, spec, xsn, csn ) {
   // TODO: general: requires other property (here: 'val')
   const type = (csn.val == null) ? 'null' : typeof csn.val;
-  if (val === type)            // also for 'object' which is an error for 'val'
-    return val;
-  if (typeof val === 'string' && validLiteralsExtra[val] === type)
-    return val;
+  if (lit === type)            // also for 'object' which is an error for 'val'
+    return lit;
+  if (typeof lit === 'string' && quotedLiteralPatterns[lit]?.json_type === type) {
+    const p = quotedLiteralPatterns[lit];
+    if (p && p.test_fn && !p.test_fn(csn.val))
+      warning( 'syntax-invalid-literal', location(), { '#': p.test_variant } );
+    return lit;
+  }
+  if (lit === 'number' && type === 'string') // special case, not a quoted literal in CDL
+    return lit;
   error( 'syntax-expected-valid', location(true), { prop: spec.msgProp },
          'Expected valid string for property $(PROP)' );
-  return ignore( val );
+  return ignore( lit );
 }
 
 function func( val, spec, xsn ) {
@@ -1535,7 +1534,7 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
     const zero = s.vZeroFor;
     if (zero) {                 // (potential) CSN v0.1.0 property
       const group = s.xorGroup;
-      if (zero && expected( zero, schema[zero] ) && !(group && xor[group])) {
+      if (expected( zero, schema[zero] ) && !(group && xor[group])) {
         replaceZeroProp( prop, zero );
         if (group)
           xor[group] = prop;
@@ -1555,7 +1554,7 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
                std: 'CSN property $(PROP) is not expected in $(OTHERPROP)',
                top: 'CSN property $(PROP) is not expected top-level',
                def: 'CSN property $(PROP) is not expected by a definition of kind $(KIND)',
-               extend: 'CSN property $(PROP) is not expected by an extend in $(OTHERPROP))',
+               extend: 'CSN property $(PROP) is not expected by an extend in $(OTHERPROP)',
                annotate: 'CSN property $(PROP) is not expected by an annotate in $(OTHERPROP)',
              } );
     // TODO: or still augment it? (but then also handle xorGroup)
@@ -1783,7 +1782,7 @@ function toXsn( csn, filename, options, messageFunctions ) {
 }
 
 
-function augment( csn, filename = 'csn.json', options = {}, messageFunctions ) {
+function augment( csn, filename = 'csn.json', options = {}, messageFunctions = {} ) {
   try {
     return toXsn( csn, filename, options, messageFunctions );
   }
@@ -1793,7 +1792,7 @@ function augment( csn, filename = 'csn.json', options = {}, messageFunctions ) {
   }
 }
 
-function parse( source, filename = 'csn.json', options = {}, messageFunctions ) {
+function parse( source, filename = 'csn.json', options = {}, messageFunctions = {} ) {
   try {
     return augment( JSON.parse(source), filename, options, messageFunctions );
   }

package/lib/json/to-csn.js

@@ -13,6 +13,7 @@
 
 const { locationString } = require('../base/messages');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
+const { pathName } = require('../compiler/utils');
 
 const compilerVersion = require('../../package.json').version;
 const creator = `CDS Compiler v${ compilerVersion }`;
@@ -126,9 +127,6 @@ const transformers = {
   // location is not renamed to $location as the name is well established in
   // XSN and too many places (also outside the compiler) had to be adapted
   location,                     // non-enumerable $location in CSN
-  $a2j: (e, csn) => {           // on artifact level
-    Object.assign( csn, e );
-  },
   $extra: (e, csn) => {
     Object.assign( csn, e );
   },
@@ -184,9 +182,11 @@ const propertyOrder = (function orderPositions() {
 }());
 
 // sync with definition in from-csn.js:
+// Note: Order here is also the property order in CSN.
 const typeProperties = [
-  'target', 'elements', 'enum', 'items', // TODO: notNull?
-  'type', 'length', 'precision', 'scale', 'srid', 'localized',
+  'target', 'elements', 'enum', 'items',
+  'cardinality', // for association publishing in views
+  'type', 'length', 'precision', 'scale', 'srid', 'localized', // TODO: notNull?
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
 ];
 
@@ -1218,8 +1218,8 @@ function value( node ) {
   if (node.$inferred && gensrcFlavor)
     return undefined;
   if (node.path) {
-    const ref = node.path.map( id => id.id ).join('.');
-    return extra( { '=': node.variant ? `${ ref }#${ node.variant.id }` : ref }, node );
+    const ref = pathName( node.path );
+    return extra( { '=': node.variant ? `${ ref }#${ pathName(node.variant.path) }` : ref }, node );
   }
   if (node.literal === 'enum')
     return extra( { '#': node.sym.id }, node );
@@ -1275,8 +1275,11 @@ function expression( node, dollarExtra ) {
     return { ref: [ node.param.val ], param: true }; // CDL rule for runtimes
   }
   if (node.path) {
+    const ref = node.path.map( pathItem );
+    if (node.path.$prefix)
+      ref.unshift( node.path.$prefix );
     // we would need to consider node.global here if we introduce that
-    return extra( { ref: node.path.map( pathItem ) }, dollarExtraNode );
+    return extra( { ref }, dollarExtraNode );
   }
   if (node.literal) {
     if (typeof node.val === node.literal || node.val === null)