@sap/cds-compiler 4.2.2 → 4.3.0

package/lib/transform/effective/associations.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const { setProp } = require('../../base/model');
+const flattening = require('../db/flattening');
+const {
+  applyTransformations, forEachDefinition, forEachMemberRecursively, implicitAs, cloneCsnNonDict,
+} = require('../../model/csnUtils');
+const associations = require('../db/associations');
+const backlinks = require('../db/backlinks');
+
+
+/**
+ * Turn managed associations into unmanaged ones by
+ * - unfolding the .keys
+ * - creating the foreign keys in .elements
+ * - adding a corresponding on-condition
+ * @param {CSN.Model} csn Input CSN - will not be transformed
+ * @param {CSN.Options} options
+ * @param {object} csnUtils
+ * @param {object} messageFunctions
+ * @param {Function} messageFunctions.error
+ * @param {Function} messageFunctions.warning
+ * @todo Remove .keys afterwards
+ * @todo Add created foreign keys into .columns in case of a query?
+ * @returns {CSN.Model}
+ */
+function turnAssociationsIntoUnmanaged( csn, options, csnUtils, { error, warning } ) {
+  // TODO: Do we really need this?
+  forEachDefinition(csn, (artifact, artifactName) => {
+    setProp(artifact, '$path', [ 'definitions', artifactName ]);
+    forEachMemberRecursively(artifact, (member, memberName, prop, path) => {
+      setProp(member, '$path', path);
+    }, [ 'definitions', artifactName ]);
+  });
+  // Flatten out the fks and create the corresponding elements
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, '_', true, csnUtils, { allowArtifact: a => a.kind === 'entity' });
+
+  // Add the foreign keys also to the columns if the association itself was explicitly selected
+  // TODO: Extend the expansion to also expand managed to their foreign
+  // TODO: Remember where in .elements we had associations and do it then?
+  applyTransformations(csn, {
+    columns: (parent, prop, columns) => {
+      const newColumns = [];
+      for (const col of columns) {
+        newColumns.push(col);
+        const element = csnUtils.getElement(col);
+        if (element && element.keys)
+          element.keys.forEach(fk => addForeignKeyToColumns(fk, newColumns, col, options));
+      }
+      parent.columns = newColumns;
+    },
+  }, [], { allowArtifact: artifact => artifact.kind === 'entity' });
+
+  forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, '_'));
+  // Calculate the on-conditions from the .keys -
+  associations.attachOnConditions(csn, csnUtils, '_');
+
+  return csn;
+}
+
+/**
+ * FKs need to be added to the .columns
+ * @todo stolen from lib/transform/db/views.js
+ * @todo Can we maybe do this during expansion already?
+ * @param {object} foreignKey
+ * @param {object[]} columns
+ * @param {CSN.Column} associationColumn
+ * @param {CSN.Options} options
+ */
+function addForeignKeyToColumns( foreignKey, columns, associationColumn, options ) {
+  const ref = cloneCsnNonDict(associationColumn.ref, options);
+  ref[ref.length - 1] = [ implicitAs(ref) ].concat(foreignKey.as || foreignKey.ref).join('_');
+  const result = {
+    ref,
+  };
+  if (associationColumn.as) {
+    const columnName = `${associationColumn.as}_${foreignKey.as || implicitAs(foreignKey.ref)}`;
+    result.as = columnName;
+  }
+
+  if (associationColumn.key)
+    result.key = true;
+
+  columns.push(result);
+}
+
+/**
+ * Translate $self backlinks to "normal" on-conditions
+ * @param {CSN.Model} csn Input CSN - will not be transformed
+ * @param {CSN.Options} options
+ * @param {object} csnUtils
+ * @param {object} messageFunctions
+ */
+function transformBacklinks( csn, options, csnUtils, messageFunctions ) {
+  forEachDefinition(csn, backlinks.getBacklinkTransformer(csnUtils, messageFunctions, options, '_', true));
+}
+
+module.exports = {
+  managedToUnmanaged: turnAssociationsIntoUnmanaged,
+  transformBacklinks,
+};

package/lib/transform/effective/main.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const { isBetaEnabled } = require('../../base/model');
+const { CompilerAssertion } = require('../../base/error');
+const { makeMessageFunction } = require('../../base/messages');
+const { cloneCsnNonDict, getUtils, isAspect } = require('../../model/csnUtils');
+const transformUtils = require('../transformUtils');
+const flattening = require('../db/flattening');
+const types = require('./types');
+// const { addLocalizationViews } = require('../../transform/localized');
+const validate = require('../../checks/validator');
+const expansion = require('../db/expansion');
+const queries = require('./queries');
+const associations = require('./associations');
+const generateDrafts = require('../draft/db');
+const handleExists = require('../db/transformExists');
+const misc = require('./misc');
+const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('../db/rewriteCalculatedElements');
+
+/**
+ * This is just a PoC for now!
+ *
+ * Transform the given CSN into a so called effective CSN, by
+ * - dissolving structured types
+ * - turning managed into unmanaged associations
+ * @private
+ * @param {CSN.Model} model Input CSN - will not be transformed
+ * @param {CSN.Options} options
+ * @returns {CSN.Model}
+ */
+function effectiveCsn( model, options ) {
+  if (!isBetaEnabled(options, 'effectiveCsn'))
+    throw new CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
+
+  const csn = cloneCsnNonDict(model, options);
+
+  const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, '_');
+  queries.projectionToSELECTAndAddColumns(csn);
+
+  let csnUtils = getUtils(csn, 'init-all');
+  const messageFunctions = makeMessageFunction(csn, options, 'for.effective');
+
+  // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
+  const cleanup = validate.forRelationalDB(csn, {
+    ...messageFunctions, csnUtils, ...csnUtils, csn, options, isAspect,
+  });
+
+  rewriteCalculatedElementsInViews(csn, options, csnUtils, '_', messageFunctions);
+
+  // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
+  handleExists(csn, options, messageFunctions.error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
+
+  // Check if structured elements and managed associations are compared in an expression
+  // and expand these structured elements. This tuple expansion allows all other
+  // subsequent procession steps to see plain paths in expressions.
+  // If errors are detected, throwWithAnyError() will return from further processing
+  expandStructsInExpression(csn, { drillRef: true });
+
+  messageFunctions.throwWithAnyError();
+
+  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils);
+
+  // Expand a structured thing in: keys, columns, order by, group by
+  expansion.expandStructureReferences(csn, options, '_', messageFunctions, csnUtils);
+
+  csnUtils = getUtils(csn, 'init-all');
+
+  // Remove properties attached by validator - they do not "grow" as the model grows.
+  cleanup();
+
+  flattening.flattenAllStructStepsInRefs(csn, options, new WeakMap(), '_');
+  flattening.flattenElements(csn, options, '_', messageFunctions.error);
+
+  resolveTypesInActionsAfterFlattening();
+
+  processCalculatedElementsInEntities(csn);
+  associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
+  associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
+  generateDrafts(csn, options, '_', messageFunctions);
+  misc.attachPersistenceName(csn, options, csnUtils);
+  misc.removeDefinitionsAndProperties(csn);
+
+  messageFunctions.throwWithError();
+
+  return csn;
+}
+
+module.exports = { effectiveCsn };

package/lib/transform/effective/misc.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const {
+  forEachDefinition, forEachMemberRecursively, getArtifactDatabaseNameOf, getElementDatabaseNameOf, forEachMember,
+} = require('../../model/csnUtils');
+/**
+ * Attach @cds.persistence.name to all artifacts and "things".
+ * We could also do it more selectively like we do in forRelationalDb, but: Why? Space maybe?
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @param {object} csnUtils
+ */
+function attachPersistenceName( csn, options, csnUtils ) {
+  const { addStringAnnotationTo } = csnUtils;
+
+  forEachDefinition(csn, (artifact, artifactName) => {
+    if (artifact.kind === 'entity') {
+      addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
+
+      forEachMemberRecursively(artifact, (member, memberName) => addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member), [ 'definitions', artifactName ]);
+    }
+  });
+}
+
+const artifactPropertiesToRemove = [ 'includes' ];
+const memberPropertiesToRemove = [ 'localized', 'enum', 'keys' ];
+
+/**
+ * Remove definitions from the CSN:
+ * - types
+ * - aspects
+ *
+ * Remove properties from artifacts:
+ * - includes
+ * - localized
+ * @param {CSN.Model} csn
+ * @todo Callback-like architecture and merge with persistence name?
+ */
+function removeDefinitionsAndProperties( csn ) {
+  forEachDefinition(csn, (artifact, artifactName) => {
+    if (artifact.kind === 'aspect' || artifact.kind === 'type') {
+      delete csn.definitions[artifactName];
+    }
+    else {
+      if (artifact['@cds.persistence.skip'] === 'if-unused')
+        artifact['@cds.persistence.skip'] = false;
+      for (const prop of artifactPropertiesToRemove)
+        delete artifact[prop];
+
+      forEachMember(artifact, (member) => {
+        for (const prop of memberPropertiesToRemove)
+          delete member[prop];
+      });
+    }
+  });
+}
+
+module.exports = {
+  attachPersistenceName,
+  removeDefinitionsAndProperties,
+};

package/lib/transform/effective/queries.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const { forEachDefinition, applyTransformationsOnNonDictionary } = require('../../model/csnUtils');
+
+/**
+ * - Make .projections look like simple SELECTS
+ * - ensure we always have a .columns by adding a .columns = ['*'] if none is present
+ * @param {CSN.Model} csn
+ * @returns {Function[]} Callbacks to re-add the .projection
+ */
+function projectionToSELECTAndAddColumns( csn ) {
+  const redoProjections = [];
+  forEachDefinition(csn, (artifact) => {
+    if (artifact.kind === 'entity') {
+      if (artifact.projection) {
+        if (!artifact.projection.columns)
+          artifact.projection.columns = [ '*' ];
+        artifact.query = { SELECT: artifact.projection };
+        delete artifact.projection;
+        redoProjections.push(() => {
+          if (artifact.query) {
+            artifact.projection = artifact.query.SELECT;
+            delete artifact.query;
+            if (artifact.$syntax === 'projection')
+              delete artifact.$syntax;
+          }
+        });
+      }
+      else if (artifact.query) {
+        applyTransformationsOnNonDictionary(artifact, 'query', {
+          SELECT: (parent, prop, SELECT) => {
+            SELECT.columns ??= [ '*' ];
+          },
+        });
+      }
+    }
+  });
+
+  return redoProjections;
+}
+
+module.exports = { projectionToSELECTAndAddColumns };

package/lib/transform/effective/types.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const {
+  cloneCsnNonDict, applyTransformations, applyTransformationsOnNonDictionary, cloneCsnDictionary, applyTransformationsOnDictionary,
+} = require('../../model/csnUtils');
+
+/**
+ * Resolve all references to structured types in entities to the underlying elements.
+ * Resolve all simple type refs to their cds builtin type.
+ *
+ * When setting the elements, we deeply clone them from the type to avoid accidental changes
+ * since they are linked by a reference.
+ * @todo What about annotations on the type?
+ * @param {CSN.Model} csn will be transformed
+ * @param {object} csnUtils
+ * @returns {Function} Callback to resolve things (actions and their returns) later - as for them, $self would lead to unresolvable constructs at this point
+ * so we can call this callback after flattening is done - then we can safely resolve their types.
+ */
+function resolveTypes( csn, csnUtils ) {
+  const { getFinalTypeInfo } = csnUtils;
+  const later = [];
+  applyTransformations(csn, {
+    type: (parent, prop, type, path) => {
+      const artifact = csn.definitions[path[1]];
+      // TODO: What about events?
+      if (!(artifact.kind === 'action' || artifact.kind === 'function'))
+        resolveType(parent);
+    },
+  }, [ (definitions, artifactName, artifact) => {
+    // In a non-flat model, replacing types with some $self inside causes issues for actions (bound or unbound)
+    // we remember them and replace them after flattening.
+    if (artifact.kind === 'action' || artifact.kind === 'function')
+      later.push({ [artifactName]: artifact });
+    else if (artifact.actions)
+      later.push(artifact.actions);
+  } ], { skipDict: { actions: true } });
+
+  return function resolveTypesInActions() {
+    later.forEach(action => applyTransformationsOnDictionary(action, { type: parent => resolveType(parent) }));
+  };
+
+  /**
+   * Resolve a type to its
+   * - elements
+   * - items
+   * - basic builtin
+   *
+   * Drill down into .elements and .items
+   *
+   * @param {object} parent Object with a .type propertie
+   */
+  function resolveType( parent ) {
+    // TODO: I assume there can be cases with a type ref but still having .elements already? Subelement anno?
+    const final = getFinalTypeInfo(parent.type);
+    if (final?.elements) {
+      // We do full clones so users don't get unexpected linkage later
+      if (!parent.elements)
+        parent.elements = cloneCsnDictionary(final.elements);
+      delete parent.type;
+    }
+    else if (final && final.items) {
+      if (!parent.items)
+        parent.items = cloneCsnNonDict(final.items);
+      delete parent.type;
+    }
+    else if (final?.type) {
+      parent.type = final.type;
+    }
+
+    // Drill down - there might be other type references
+    const stack = [ ];
+    if (parent.elements || parent.items)
+      stack.push(parent);
+    while (stack.length > 0) {
+      const obj = stack.pop();
+      if (obj.elements) {
+        applyTransformationsOnDictionary(obj.elements, {
+          type: getTypeTransformer(stack),
+        }, { skipDict: { actions: true } });
+      }
+      else if (obj.items) {
+        applyTransformationsOnNonDictionary(obj, 'items', {
+          type: getTypeTransformer(stack),
+        }, { skipDict: { actions: true } });
+      }
+    }
+  }
+
+  /**
+   * Function to transform a type to its most basic thing
+   * @param {object[]} stack
+   * @returns {Function}
+   */
+  function getTypeTransformer( stack ) {
+    return function typeTransformer( _parent, _prop, _type ) {
+      const finalSub = getFinalTypeInfo(_type);
+
+      if (finalSub?.elements) {
+        // We do full clones so users don't get unexpected linkage later
+        if (!_parent.elements)
+          _parent.elements = cloneCsnDictionary(finalSub.elements);
+        delete _parent.type;
+        stack.push( _parent );
+      }
+      else if (finalSub?.items) {
+        if (!_parent.items)
+          _parent.items = cloneCsnNonDict(finalSub.items);
+        delete _parent.type;
+        stack.push( _parent );
+      }
+      else if (finalSub?.type) {
+        _parent.type = finalSub.type;
+      }
+    };
+  }
+}
+
+
+module.exports = {
+  resolve: resolveTypes,
+};