@sap/cds-compiler 2.15.8 → 3.1.0

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,
+};