@sap/cds-compiler 6.2.2 → 6.3.0

package/lib/transform/draft/db.js

@@ -4,7 +4,7 @@ const {
   getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively, applyAnnotationsFromExtensions,
 } = require('../../model/csnUtils');
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const { forEach } = require('../../utils/objectUtils');
@@ -56,10 +56,10 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
 
       // Redirect associations/compositions between draft shadow nodes
       for (const name in draftNodes) {
-        const shadowNode = csn.definitions[`${name}${draftSuffix}`];
+        const shadowNode = csn.definitions[`${ name }${ draftSuffix }`];
         // Might not exist because of previous errors
         if (shadowNode)
-          redirectDraftTargets(csn.definitions[`${name}${draftSuffix}`], draftNodes);
+          redirectDraftTargets(csn.definitions[`${ name }${ draftSuffix }`], draftNodes);
       }
     }
   }
@@ -84,7 +84,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
         const draftNodeName = elem.target;
         // Sanity check
         if (!draftNode)
-          throw new ModelError(`Expecting target to be resolved: ${JSON.stringify(elem, null, 2)}`);
+          throw new ModelError(`Expecting target to be resolved: ${ JSON.stringify(elem, null, 2) }`);
 
         // Ignore composition if not part of a service
         if (!isPartOfService(draftNodeName)) {
@@ -115,11 +115,11 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   function generateDraftForHana( artifact, artifactName, draftRootName ) {
     // Sanity check
     if (!isPartOfService(artifactName))
-      throw new ModelError(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
+      throw new ModelError(`Expecting artifact to be part of a service: ${ JSON.stringify(artifact) }`);
 
 
     // The name of the draft shadow entity we should generate
-    const draftsArtifactName = `${artifactName}${draftSuffix}`;
+    const draftsArtifactName = `${ artifactName }${ draftSuffix }`;
 
     generatedArtifacts[draftsArtifactName] = true;
 
@@ -132,7 +132,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     // Ignore boolean return value. We know that we're inside a service or else we wouldn't have reached this code.
     const matchingService = getMatchingService(artifactName) || '';
     // Generate the DraftAdministrativeData projection into the service, unless there is already one
-    const draftAdminDataProjectionName = `${matchingService}.DraftAdministrativeData`;
+    const draftAdminDataProjectionName = `${ matchingService }.DraftAdministrativeData`;
     let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
     if (!draftAdminDataProjection) {
       generatedArtifacts[draftAdminDataProjectionName] = true;
@@ -232,10 +232,9 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     draftAdministrativeData.DraftAdministrativeData.notNull = true;
     addElement(draftAdministrativeData, draftsArtifact, artifactName);
 
-    if (isBetaEnabled(options, 'draftMessages') || options.draftMessages) {
-      const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
-      addElement(draftMessages, draftsArtifact, artifactName);
-    }
+    const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
+    addElement(draftMessages, draftsArtifact, artifactName);
+
     // Note that we may need to do the HANA transformation steps for managed associations
     // (foreign key field generation, generatedFieldName, creating ON-condition) by hand,
     // because the corresponding transformation steps have already been done on all artifacts
@@ -278,18 +277,19 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
       const sourceElement = source.elements[draftUUIDKey.ref[0]];
       const targetElement = {};
       forEach(sourceElement, (key, value) => {
-        if(!key.startsWith('@') && key !== 'key')
+        if (!key.startsWith('@') && key !== 'key')
           targetElement[key] = value;
-      })
+      });
 
-      if(sourceElement.key) targetElement.notNull = true;
+      if (sourceElement.key)
+        targetElement.notNull = true;
 
-      draftsArtifact.elements['DraftAdministrativeData' + (options.sqlMapping === 'hdbcds' ? '.' : '_') + draftUUIDKey.ref[0]] =  targetElement;
+      draftsArtifact.elements[`DraftAdministrativeData${ options.sqlMapping === 'hdbcds' ? '.' : '_' }${ draftUUIDKey.ref[0] }`] = targetElement;
 
       draftAdministrativeData.DraftAdministrativeData.on = createAssociationPathComparison('DraftAdministrativeData',
                                                                                            getNameForRef(draftUUIDKey),
                                                                                            '=',
-                                                                                           `DraftAdministrativeData${pathDelimiter}DraftUUID`);
+                                                                                           `DraftAdministrativeData${ pathDelimiter }DraftUUID`);
       // The notNull has been transferred to the foreign key field and must be removed on the association
       delete draftAdministrativeData.DraftAdministrativeData.notNull;
 
@@ -337,9 +337,9 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     function getDraftShadowEntityFor( draftNode, draftNodeName ) {
       // Sanity check
       if (!draftNodes[draftNodeName])
-        throw new ModelError(`Not a draft node: ${draftNodeName}`);
+        throw new ModelError(`Not a draft node: ${ draftNodeName }`);
 
-      return { shadowTarget: csn.definitions[`${draftNodeName}${draftSuffix}`], shadowTargetName: `${draftNodeName}${draftSuffix}` };
+      return { shadowTarget: csn.definitions[`${ draftNodeName }${ draftSuffix }`], shadowTargetName: `${ draftNodeName }${ draftSuffix }` };
     }
   }
 
@@ -351,7 +351,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
    */
   function isPartOfService( artifactName ) {
     for (const serviceName of allServices) {
-      if (artifactName.startsWith(`${serviceName}.`))
+      if (artifactName.startsWith(`${ serviceName }.`))
         return true;
     }
 
@@ -369,7 +369,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     /** @type {false|string} */
     let match = false;
     for (const serviceName of allServices) {
-      if (artifactName.startsWith(`${serviceName}.`) && (!match || serviceName.length < match.length))
+      if (artifactName.startsWith(`${ serviceName }.`) && (!match || serviceName.length < match.length))
         match = serviceName;
     }
     return match;

package/lib/transform/draft/odata.js

@@ -1,13 +1,14 @@
 'use strict';
 
-const { forEachDefinition, forEachMemberRecursively,
+const {
+  forEachDefinition, forEachMemberRecursively,
   getServiceNames, applyAnnotationsFromExtensions,
-  transformAnnotationExpression } = require('../../model/csnUtils');
+  transformAnnotationExpression,
+} = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
 const { getTransformers } = require('../transformUtils');
 const { makeMessageFunction } = require('../../base/messages');
-const { isBetaEnabled } = require('../../base/model');
 
 /**
  * - Generate artificial draft fields if requested
@@ -59,7 +60,7 @@ function generateDrafts( csn, options, services, messageFunctions ) {
   const filterDict = Object.create(null);
 
   // validate the 'DRAFT.DraftAdministrativeData_DraftMessage' type if already present in the model
-  if (isBetaEnabled(options, 'draftMessages') || options.draftMessages) {
+  if (options.draftMessages) {
     const draftAdminDataMessagesType = csn.definitions['DRAFT.DraftAdministrativeData_DraftMessage'];
     if (draftAdminDataMessagesType && !isValidDraftAdminDataMessagesType(draftAdminDataMessagesType)) {
       error(null, [ 'definitions', 'DRAFT.DraftAdministrativeData_DraftMessage' ], { name: 'DRAFT.DraftAdministrativeData_DraftMessage' },
@@ -98,7 +99,7 @@ function generateDrafts( csn, options, services, messageFunctions ) {
         artifact.actions && artifact.actions.draftPrepare)
       return;
 
-    if(!visitedArtifacts[artifactName])
+    if (!visitedArtifacts[artifactName])
       visitedArtifacts[artifactName] = artifact;
 
     const draftPrepare = createAction('draftPrepare', artifactName, 'SideEffectsQualifier', 'cds.String');
@@ -118,7 +119,7 @@ function generateDrafts( csn, options, services, messageFunctions ) {
 
     // Generate the DraftAdministrativeData projection into the service, unless there is already one
     // @ts-ignore
-    const draftAdminDataProjectionName = `${getServiceOfArtifact(artifactName, services)}.DraftAdministrativeData`;
+    const draftAdminDataProjectionName = `${ getServiceOfArtifact(artifactName, services) }.DraftAdministrativeData`;
     let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
     if (!draftAdminDataProjection) {
       // @ts-ignore
@@ -180,19 +181,15 @@ function generateDrafts( csn, options, services, messageFunctions ) {
     // ... on SiblingEntity.IsActiveEntity != IsActiveEntity ...
     siblingEntity.SiblingEntity.on = createAssociationPathComparison('SiblingEntity', 'IsActiveEntity', '!=', 'IsActiveEntity');
 
-    if (isBetaEnabled(options, 'draftMessages') || options.draftMessages) {
+    if (options.draftMessages) {
       const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
       addElement(draftMessages, artifact, artifactName);
 
       if (!artifact['@Common.SideEffects#alwaysFetchMessages'] && artifact['@Common.SideEffects#alwaysFetchMessages'] !== null) {
-        setAnnotation(artifact, '@Common.SideEffects#alwaysFetchMessages.SourceEntities', ['']);
-        setAnnotation(artifact, '@Common.SideEffects#alwaysFetchMessages.TargetProperties', ['DraftMessages'] );
+        setAnnotation(artifact, '@Common.SideEffects#alwaysFetchMessages.SourceEntities', [ '' ]);
+        setAnnotation(artifact, '@Common.SideEffects#alwaysFetchMessages.TargetProperties', [ 'DraftMessages' ] );
       }
-      setAnnotation(artifact, '@Common.Messages', { '=': 'DraftMessages', ref: ['DraftMessages'] });
-      setAnnotationAddressViaNavigationPath(artifactName, services);
-    }
-
-    if (options.addAnnotationAddressViaNavigationPath) {
+      setAnnotation(artifact, '@Common.Messages', { '=': 'DraftMessages', ref: [ 'DraftMessages' ] });
       setAnnotationAddressViaNavigationPath(artifactName, services);
     }
 
@@ -249,50 +246,51 @@ function generateDrafts( csn, options, services, messageFunctions ) {
     }
   }
 
-    /*
-     * After draft decoration, all visited artifacts are supposed to have the draft state elements
-     * Is/HasActiveEntity, HasDraftEntity. Now, $draft.<postfix> (with postfix defined as magic variable
-     * in the core compiler builtins) needs to be translated into $self.<postfix>.
-     *
-     * It has to be processed after the late 'applyAnnotationsFromExtensions' which could also merge in
-     * some $draft path expressions.
+  /*
+   * After draft decoration, all visited artifacts are supposed to have the draft state elements
+   * Is/HasActiveEntity, HasDraftEntity. Now, $draft.<postfix> (with postfix defined as magic variable
+   * in the core compiler builtins) needs to be translated into $self.<postfix>.
+   *
+   * It has to be processed after the late 'applyAnnotationsFromExtensions' which could also merge in
+   * some $draft path expressions.
   */
   function rewriteDollarDraft() {
-
     function $draft2$self(member) {
-      Object.keys(member).forEach(pn => {
-        if(pn[0] === '@') {
+      Object.keys(member).forEach((pn) => {
+        if (pn[0] === '@') {
           transformAnnotationExpression(member, pn, {
-              ref: (_parent, _prop, xpr, _path, _p, _ppn, ctx) => {
-                if(xpr[0] === '$draft') {
-                  xpr[0] = '$self';
-                  if(ctx?.annoExpr?.['='])
-                    ctx.annoExpr['='] = true;
-                }
+            ref: (_parent, _prop, xpr, _path, _p, _ppn, ctx) => {
+              if (xpr[0] === '$draft') {
+                xpr[0] = '$self';
+                if (ctx?.annoExpr?.['='])
+                  ctx.annoExpr['='] = true;
               }
             },
-          );
+          });
         }
       });
     }
 
     // entity parameters are not substituted as the EDM param entity is not draft enabled
-    Object.entries(visitedArtifacts).forEach(([artName, art]) => {
+    Object.entries(visitedArtifacts).forEach(([ artName, art ]) => {
       $draft2$self(art);
-      forEachMemberRecursively(art, $draft2$self,
+      forEachMemberRecursively(
+        art, $draft2$self,
         [ 'definitions', artName ],
         true, { elementsOnly: true }
       );
-      if(art.actions) {
-        Object.entries(art.actions).forEach(([actionName, action]) => {
+      if (art.actions) {
+        Object.entries(art.actions).forEach(([ actionName, action ]) => {
           $draft2$self(action);
-          forEachMemberRecursively(action, $draft2$self,
-          [ 'definitions', artName, 'actions',  actionName ]);
-          if(action.returns)
+          forEachMemberRecursively(
+            action, $draft2$self,
+            [ 'definitions', artName, 'actions', actionName ]
+          );
+          if (action.returns)
             $draft2$self(action.returns);
-        })
+        });
       }
-    })
+    });
   }
 
   // Set the @Common.AddressViaNavigationPath annotation to the service of

package/lib/transform/effective/associations.js

@@ -43,7 +43,7 @@ function turnAssociationsIntoUnmanaged( csn, options, csnUtils, messageFunctions
     orderBy: expandManagedToFksInArray(true),
   }, [], { allowArtifact: artifact => artifact.query !== undefined || artifact.projection !== undefined });
 
-  forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, '_', true));
+  forEachDefinition(csn, associations.getFKAccessFinalizer(csn, options, csnUtils, '_', true));
   applyTransformations(csn, {
     elements: (_parent, prop, elements, path) => {
       forEachMember(_parent, (element, elementName, _prop, elPath) => {

package/lib/transform/effective/flattening.js

@@ -55,54 +55,47 @@ function flattenRefs(csn, options, csnUtils, messageFunctions) {
   const refFlattener = getStructStepsFlattener(csn, options, messageFunctions, resolved, '_', adaptRefs);
 
   forEachDefinition(csn, (def, defName) => {
-    if (def.kind === 'entity') {
-      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: true, skipDict: { actions: 1 } }, [ 'definitions' ]);
-
-      adaptRefs.forEach(fn => fn());
-      adaptRefs.length = 0;
-
-      // explicit binding parameter of bound action
-      if (def.actions) {
-        const special$self = !csn?.definitions?.$self && '$self';
-        Object.entries(def.actions).forEach(([ an, a ]) => {
-          if (a.params) {
-            const params = Object.entries(a.params);
-            const firstParam = params[0][1];
-            const type = firstParam?.items?.type || firstParam?.type;
-            if (type === special$self) {
-              const bindingParamName = params[0][0];
-              const markBindingParam = {
-                ref: (parent, prop, xpr) => {
-                  if ((xpr[0].id || xpr[0]) === bindingParamName)
-                    setProp(parent, '$bparam', true);
-                },
-              };
-
-              Object.keys(a)
-                .filter(pn => pn.startsWith('@') && a[pn])
-                .forEach((pn) => {
-                  transformAnnotationExpression(a, pn, [ markBindingParam, refFlattener ], [ 'definitions', defName, 'actions', an ]);
-                  adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
-                  adaptRefs.length = 0;
-                });
-
-
-              forEachMemberRecursively(a, (member, memberName, prop, path) => {
-                Object.keys(member).filter(pn => pn.startsWith('@') && member[pn]).forEach((pn) => {
-                  transformAnnotationExpression(member, pn, [ markBindingParam, refFlattener ], path);
-                  adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
-                  adaptRefs.length = 0;
-                });
-              }, [ 'definitions', defName, 'actions', an ]);
-            }
+    applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: true, skipDict: { actions: 1 } }, [ 'definitions' ]);
+
+    adaptRefs.forEach(fn => fn());
+    adaptRefs.length = 0;
+
+    // explicit binding parameter of bound action
+    if (def.actions) {
+      const special$self = !csn?.definitions?.$self && '$self';
+      Object.entries(def.actions).forEach(([ an, a ]) => {
+        if (a.params) {
+          const params = Object.entries(a.params);
+          const firstParam = params[0][1];
+          const type = firstParam?.items?.type || firstParam?.type;
+          if (type === special$self) {
+            const bindingParamName = params[0][0];
+            const markBindingParam = {
+              ref: (parent, prop, xpr) => {
+                if ((xpr[0].id || xpr[0]) === bindingParamName)
+                  setProp(parent, '$bparam', true);
+              },
+            };
+
+            Object.keys(a)
+              .filter(pn => pn.startsWith('@') && a[pn])
+              .forEach((pn) => {
+                transformAnnotationExpression(a, pn, [ markBindingParam, refFlattener ], [ 'definitions', defName, 'actions', an ]);
+                adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
+                adaptRefs.length = 0;
+              });
+
+
+            forEachMemberRecursively(a, (member, memberName, prop, path) => {
+              Object.keys(member).filter(pn => pn.startsWith('@') && member[pn]).forEach((pn) => {
+                transformAnnotationExpression(member, pn, [ markBindingParam, refFlattener ], path);
+                adaptRefs.forEach(fn => fn(true, 1, parent => parent.$bparam));
+                adaptRefs.length = 0;
+              });
+            }, [ 'definitions', defName, 'actions', an ]);
           }
-        });
-      }
-    }
-    else {
-      applyTransformationsOnNonDictionary(csn.definitions, defName, refFlattener, { processAnnotations: false }, [ 'definitions' ]);
-      adaptRefs.forEach(fn => fn());
-      adaptRefs.length = 0;
+        }
+      });
     }
   });
 

package/lib/transform/effective/main.js

@@ -39,10 +39,12 @@ function effectiveCsn( model, options, messageFunctions ) {
   messageFunctions.setModel(csn);
 
   const transformerUtils = transformUtils.getTransformers(csn, options, messageFunctions, '_');
-  const { expandStructsInExpression } = transformerUtils;
   const redoProjections = queries.projectionToSELECTAndAddColumns(csn);
 
-  let csnUtils = getUtils(csn, 'init-all');
+  // re-use from transformers; otherwise we have two caches and tuple expansion
+  // would use a different one than handleExists, leading to unnecessary re-initialization
+  let { csnUtils } = transformerUtils;
+  csnUtils.initAllDefinitions();
 
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
@@ -53,13 +55,13 @@ function effectiveCsn( model, options, messageFunctions ) {
     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);
+  handleExists(csn, options, messageFunctions, csnUtils);
 
   // 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 });
+  transformerUtils.expandStructsInExpression({ drillRef: true });
 
   messageFunctions.throwWithAnyError();