@sap/cds-compiler 4.6.2 → 4.7.4

package/lib/transform/forOdata.js

@@ -2,8 +2,7 @@
 
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtils');
-const { cloneCsnNonDict,
-        forEachDefinition,
+const { forEachDefinition,
         forEachMemberRecursively,
         applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf,
@@ -18,13 +17,15 @@ const { isArtifactInSomeService, isLocalizedArtifactInService } = require('./oda
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const { timetrace } = require('../utils/timetrace');
 const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
-const flattening = require('./db/flattening');
+const flattening = require('./odata/flattening');
 const associations = require('./db/associations')
 const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
 
 const { addTenantFields } = require('./addTenantFields');
 const { addLocalizationViews } = require('./localized');
+const { cloneFullCsn } = require('../model/cloneCsn');
+const { csnRefs } = require('../model/csnRefs');
 
 // Transformation for ODATA. Expects a CSN 'inputModel', processes it for ODATA.
 // The result should be suitable for consumption by EDMX processors (annotations and metadata)
@@ -72,7 +73,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   timetrace.start('OData transformation');
 
   // copy the model as we don't want to change the input model
-  let csn = cloneCsnNonDict(inputModel, options);
+  let csn = cloneFullCsn(inputModel, options);
   messageFunctions.setModel(csn);
 
   const { message, error, warning, info, throwWithAnyError } = messageFunctions;
@@ -118,7 +119,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
 
-  if (options.tenantAsColumn)
+  if (options.tenantDiscriminator)
     addTenantFields(csn, options);
 
   const keepLocalizedViews = isDeprecatedEnabled(options, '_createLocalizedViews');
@@ -133,6 +134,9 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // replace all type refs to builtin types with direct type
   transformUtils.rewriteBuiltinTypeRef(csn);
 
+    // Rewrite paths in annotations only if beta modes are set
+
+  options.enrichAnnotations = true;
   const cleanup = validate.forOdata(csn, {
     message, error, warning, info, inspectRef, effectiveType, getFinalTypeInfo, artifactRef,
     options, csnUtils, services, isAspect, isExternalServiceMember, recurseElements,
@@ -165,11 +169,11 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // If in the future 'other' APIs that might support type refs are imported, these refs must be
   // resolved here, as this is the OData transformation and sets the foundation for subsequent EDM
   // rendering which may has to publish external definitions
-  expandToFinalBaseType(csn, transformers, csnUtils, services, options);
+  expandToFinalBaseType(csn, transformers, csnUtils, services, options, error);
 
   // - Generate artificial draft fields on a structured CSN if requested, flattening and struct
   //   expansion do their magic including foreign key generation and annotation propagation.
-  generateDrafts(csn, options, services);
+  generateDrafts(csn, options, services, messageFunctions);
 
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
@@ -180,21 +184,30 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   if (!structuredOData) {
     expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, csnUtils, { skipArtifact: isExternalServiceMember });
     const resolved = new WeakMap();
-    // No refs with struct-steps exist anymore
-
-    flattening.flattenAllStructStepsInRefs(csn, options, messageFunctions, resolved, '_', { skipArtifact: isExternalServiceMember });
-    // No type references exist anymore
-    // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
-    // OData doesn't resolve type chains after the first 'items'
-    flattening.resolveTypeReferences(csn, options, messageFunctions, resolved, '_',
-      { skip: [ 'action', 'aspect', 'event', 'function', 'type'],
-        skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
-    // No structured elements exists anymore
-    flattening.flattenElements(csn, options, messageFunctions, '_',
-      { skip: ['action', 'aspect', 'event', 'function', 'type'],
+
+    const { inspectRef, effectiveType } = csnRefs(csn);
+    const { adaptRefs, transformer: refFlattener } = flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
+
+    flattening.allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternalServiceMember, error, csnUtils, options);
+
+    flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs,
+      { //skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
-        skipStandard: { items: true },  // don't drill further into .items
-        skipDict: { actions: true } }); // don't drill further into .actions -> bound actions, action-artifacts are handled by skip
+      });
+
+    // replace structured with flat dictionaries that contain
+    // rewritten path expressions
+    forEachDefinition(csn, (def) => {
+      ['elements', 'params'].forEach(dictName => {
+        if(def[`$${dictName}`])
+          def[dictName] = def[`$${dictName}`];
+      })
+      if(def.$flatAnnotations) {
+        Object.entries(def.$flatAnnotations).forEach(([an, av]) => {
+          def[an] = av; 
+        })
+      }
+    });
   }
 
   // TODO: add the generated foreign keys to the columns when we are in a view
@@ -249,7 +262,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
           !(propertyName === 'enum' || propertyName === 'returns') &&
           (!member.virtual || def.query)) {
         // If we have a 'preserved dotted name' (i.e. we are a result of flattening), use that for the @cds.persistence.name annotation
-        member['@cds.persistence.name'] = getElementDatabaseNameOf(member._flatElementNameWithDots || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
+        member['@cds.persistence.name'] = getElementDatabaseNameOf(member.$defPath?.slice(1).join('.') || memberName, options.sqlMapping, 'hana'); // hana to allow "hdbcds"
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -282,13 +295,15 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     forEachGeneric(csn, 'vocabularies', renameShorthandAnnotations);
   }
 
+  cleanup();
   // Throw exception in case of errors
   throwWithAnyError();
-  cleanup();
-  if (options.testMode) csn = cloneCsnNonDict(csn, options);   // sort, keep hidden properties
   timetrace.stop('OData transformation');
   return csn;
 
+  //--------------------------------------------------------------------
+  // HELPER SECTION STARTS HERE
+
   // Mark elements that are annotated with @odata.on.insert/update with the annotation @Core.Computed.
   function annotateCoreComputed(node) {
     // If @Core.Computed is explicitly set, don't overwrite it!

package/lib/transform/forRelationalDB.js

@@ -1,8 +1,7 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { cloneCsnNonDict,
-        forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
+const { forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isAspect, walkCsnPath, isPersistedOnDatabase
       } = require('../model/csnUtils');
@@ -32,6 +31,8 @@ const temporal = require('./db/temporal');
 const associations = require('./db/associations');
 const backlinks = require('./db/backlinks');
 const { getDefaultTypeLengths } = require('../render/utils/common');
+const { featureFlags } = require('./db/featureFlags');
+const { cloneCsnNonDict, cloneFullCsn } = require('../model/cloneCsn');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -108,10 +109,10 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   timetrace.start('Clone CSN');
   /** @type {CSN.Model} */
-  csn = cloneCsnNonDict(csn, options);
+  csn = cloneFullCsn(csn, options);
   timetrace.stop('Clone CSN');
 
-  if (options.tenantAsColumn)
+  if (options.tenantDiscriminator)
     addTenantFields(csn, options);
 
   checkCSNVersion(csn, options);
@@ -161,7 +162,8 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   // exit if validators found errors
   throwWithAnyError();
 
-  rewriteCalculatedElementsInViews(csn, options, csnUtils, pathDelimiter, messageFunctions);
+  if(csn.meta?.[featureFlags]?.$calculatedElements)
+    rewriteCalculatedElementsInViews(csn, options, csnUtils, pathDelimiter, messageFunctions);
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
   handleExists(csn, options, error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
@@ -197,7 +199,6 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
 
   bindCsnReferenceOnly();
 
-
   // TODO: Instead of 3 separate applyTransformations, we could have each of them just return the "listeners", merge them into
   // one big listener that then gets passed into one single applyTransformations. Each listener would then have to return an array of callbacks to call.
   // With that, we could still ensure the processing order (assuming we don't run into problems with scoping).
@@ -395,18 +396,20 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     delete parent[prop];
   }
 
+  function killParent(parent, a, b, path){
+    if(path.length > 2) {
+      const tail = path[path.length-1];
+      const parentPath = path.slice(0, -1)
+      const parentParent = walkCsnPath(csn, parentPath);
+      delete parentParent[tail];
+    } else {
+      delete parent.$ignore;
+    }
+  }
+
   const killers = {
     // Used to ignore actions etc from processing and remove associations/elements
-    '$ignore': function (parent, a, b, path){
-      if(path.length > 2) {
-        const tail = path[path.length-1];
-        const parentPath = path.slice(0, -1)
-        const parentParent = walkCsnPath(csn, parentPath);
-        delete parentParent[tail];
-      } else {
-        delete parent.$ignore;
-      }
-    },
+    '$ignore': killParent,
     // Still used in flattenStructuredElements - in db/flattening.js
     '_flatElementNameWithDots': killProp,
     // Set when setting default string/binary length - used in copyTypeProperties and fixBorkedElementsOfLocalized
@@ -442,13 +445,16 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
     }
   }
 
-  applyTransformations(csn, killers, [], { skipIgnore: false});
+  if(options.sqlDialect === 'hana' && options.withHanaAssociations === false && doA2J) {
+    killers.target = killParent;
+  }
+
+  applyTransformations(csn, killers, [], { skipIgnore: false });
 
   redoProjections.forEach(fn => fn());
 
   timetrace.stop('Transform CSN');
   timetrace.stop('HANA transformation');
-
   return csn;
 
   /* ----------------------------------- Functions start here -----------------------------------------------*/
@@ -548,15 +554,16 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
         // First pass: Set alias name for SELECTs without table alias. Required for setting proper table aliases
         // for HDBCDS in naming mode HDBCDS.  We use the same schema as the core-compiler, so duplicates should
         // have already been reported.
-        let selectDepth = 0;
-        traverseQuery(artifact.query, null, null, (query, fromSelect) => {
-          if (!query.ref && !query.as && fromSelect) {
-            // Use +1; for UNION, it's the next select, for SELECT, it's increased later.
-            query.as = `$_select_${selectDepth + 1}__`;
-          }
-          if (query.SELECT)
-            ++selectDepth;
-        });
+        if(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
+          let selectDepth = 0;
+          traverseQuery(artifact.query, null, null, (query, fromSelect) => {
+            if (!query.ref && !query.as && fromSelect) {
+              // Use +1; for UNION, it's the next select, for SELECT, it's increased later.
+              query.as = `$_select_${selectDepth + 1}__`;
+            }
+            if (query.SELECT) ++selectDepth;
+          });
+        }
 
         const process = (parent, prop, query, path) => {
           transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop))

package/lib/transform/localized.js

@@ -5,15 +5,18 @@ const { setProp, isDeprecatedEnabled} = require('../base/model');
 const { forEachKey } = require('../utils/objectUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
-  cloneCsnDictionary,
-  cloneCsnNonDict,
   applyAnnotationsFromExtensions,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
-  sortCsnDefinitionsForTests,
 } = require('../model/csnUtils');
-const {CompilerAssertion} = require('../base/error');
+const { CompilerAssertion } = require('../base/error');
+const {
+  cloneCsnDict,
+  cloneCsnNonDict,
+  sortCsnDefinitionsForTests,
+  sortCsn
+} = require('../model/cloneCsn');
 
 /**
  * Indicator that a definition is localized and has a convenience view.
@@ -104,7 +107,7 @@ const annoPersistenceSkip = '@cds.persistence.skip';
  *     If true, do not emit a warning for annotations on unknown `localized.*` views.
  */
 function _addLocalizationViews(csn, options, config) {
-  const messageFunctions = makeMessageFunction(csn, options);
+  const messageFunctions = makeMessageFunction(csn, options, 'localized');
   if (checkExistingLocalizationViews(csn, options, messageFunctions))
     return csn;
 
@@ -117,7 +120,7 @@ function _addLocalizationViews(csn, options, config) {
   createTransitiveConvenienceViews(); // 2 + 3
   cleanDefinitionSymbols();
   applyAnnotationsForLocalizedViews();
-  sortCsnDefinitionsForTests(csn, options);
+  sortLocalizedForTests(csn, options);
   messageFunctions.throwWithError();
   return csn;
 
@@ -201,7 +204,7 @@ function _addLocalizationViews(csn, options, config) {
           columns,
         },
       },
-      elements: cloneCsnDictionary(entity.elements, options),
+      elements: cloneCsnDict(entity.elements, options),
       [_isViewForEntity]: true,
     };
     copyLocation(convenienceView, entity);
@@ -280,7 +283,7 @@ function _addLocalizationViews(csn, options, config) {
     else if (view.projection)
       convenienceView.projection = cloneCsnNonDict(view.projection, options);
 
-    convenienceView.elements = cloneCsnDictionary(view.elements, options);
+    convenienceView.elements = cloneCsnDict(view.elements, options);
     convenienceView[_isViewForView] = true;
     copyLocation(convenienceView, view);
 
@@ -289,7 +292,7 @@ function _addLocalizationViews(csn, options, config) {
     });
 
     if (view.params)
-      convenienceView.params = cloneCsnDictionary(view.params, options);
+      convenienceView.params = cloneCsnDict(view.params, options);
 
     return convenienceView;
   }
@@ -842,6 +845,23 @@ function hasLocalizedConvenienceView(csn, artifactName) {
   return !isInLocalizedNamespace(artifactName) && !!csn.definitions[`localized.${ artifactName }`];
 }
 
+/**
+ * For tests (testMode), sort the generated localized definitions, i.e. their props,
+ * but also sort 'csn.definitions' if requested.
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ */
+function sortLocalizedForTests(csn, options) {
+  if (options.testMode) {
+    for (const defName in csn.definitions) {
+      if (defName.startsWith('localized.'))
+        csn.definitions[defName] = sortCsn(csn.definitions[defName], options);
+    }
+  }
+  sortCsnDefinitionsForTests(csn, options);
+}
+
 module.exports = {
   addLocalizationViews,
   addLocalizationViewsWithJoins,