@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/transform/db/applyTransformations.js

@@ -0,0 +1,189 @@
+'use strict';
+
+/**
+ * Module for general (partial) CSN looper functions, respecting dictionaries and allowing
+ * to pass custom callbacks for certain properties like "ref".
+ *
+ * Functions are also published in csnUtils.js for convenience.
+ *
+ * They should stay here due to the stricter linter rules for the time being.
+ *
+ * @module lib/transform/db/applyTransformations
+ */
+const { setProp } = require('../../base/model');
+
+
+/**
+ * @param {object} parent The "parent" of which we transform a property of
+ * @param {string} prop The property of parent to start at
+ * @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
+ * @param {CSN.Path} path Path to parent
+ * @returns {object} parent with transformations applied
+ */
+function applyTransformationsInternal(parent, prop, customTransformers, artifactTransformers, skipIgnore, options, path = []) {
+  const transformers = {
+    elements: dictionary,
+    definitions: dictionary,
+    actions: dictionary,
+    params: dictionary,
+    enum: dictionary,
+    mixin: dictionary,
+    ref: pathRef,
+  };
+
+  const csnPath = [ ...path ];
+  if (prop === 'definitions')
+    definitions( parent, 'definitions', parent.definitions );
+  else
+    standard(parent, prop, parent[prop]);
+  return parent;
+
+  /**
+   * Default transformer for things that are not dictionaries, like "type" or "keys".
+   * The customTransformers are applied here (and only here).
+   *
+   * @param {object | Array} _parent the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {object} node The value of node[_prop]
+   */
+  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 (const 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();
+  }
+
+  /**
+   * Transformer for things that are dictionaries - like "elements".
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {object} dict The value of node[_prop]
+   */
+  function dictionary( node, _prop, dict ) {
+    // Allow skipping dicts like actions in forHanaNew
+    if (options.skipDict && options.skipDict[_prop])
+      return;
+    csnPath.push( _prop );
+    for (const name of Object.getOwnPropertyNames( dict ))
+      standard( dict, name, dict[name] );
+
+    if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
+      setProp(node, `$${_prop}`, dict);
+    csnPath.pop();
+  }
+
+  /**
+   * Special version of "dictionary" to apply artifactTransformers.
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {object} dict The value of node[_prop]
+   */
+  function definitions( node, _prop, dict ) {
+    csnPath.push( _prop );
+    for (const 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 - because in a .ref we can have .args and .where
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {any} _path The value of node[_prop]
+   */
+  function pathRef( node, _prop, _path ) {
+    csnPath.push( _prop );
+    _path.forEach( ( 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();
+  }
+}
+
+/**
+ * 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 = {} ) {
+  if (csn && csn.definitions)
+    return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, skipIgnore, options);
+  return csn;
+}
+
+
+/**
+ * Instead of looping through the whole model, start at a given thing (like an on-condition),
+ * as long as it is not a dictionary.
+ *
+ * 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} parent The "parent" of which we transform a property of
+ * @param {string} prop The property of parent to start at
+ * @param {object} customTransformers Map of prop to transform and function to apply
+ * @param {CSN.Path} path Path pointing to parent
+ * @returns {object} parent[prop] with transformations applied
+ */
+function applyTransformationsOnNonDictionary(parent, prop, customTransformers = {}, path = []) {
+  return applyTransformationsInternal(parent, prop, customTransformers, [], true, {}, path)[prop];
+}
+
+module.exports = {
+  applyTransformations,
+  applyTransformationsOnNonDictionary,
+};