@sap/cds-compiler 2.13.8 → 2.15.2

package/lib/transform/forHanaNew.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { getUtils, cloneCsn,
+const { getUtils, cloneCsnNonDict,
         forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isAspect, walkCsnPath,
@@ -16,7 +16,7 @@ const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../che
 const { addLocalizationViewsWithJoins, addLocalizationViews } = require('../transform/localized');
 const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
-const { createDict } = require('../utils/objectUtils');
+const { createDict, forEach } = require('../utils/objectUtils');
 const handleExists = require('./db/transformExists');
 const replaceAssociationsInGroupByOrderBy = require('./db/groupByOrderBy');
 const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
@@ -106,7 +106,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
   /** @type {CSN.Model} */
-  let csn = cloneCsn(inputModel, options);
+  let csn = cloneCsnNonDict(inputModel, options);
 
 
 
@@ -116,14 +116,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   let message, error, warning, info; // message functions
   /** @type {() => void} */
-  let throwWithError;
+  let throwWithAnyError;
   let artifactRef, inspectRef, effectiveType, get$combined,
     getFinalBaseType, // csnUtils (csnRefs)
     addDefaultTypeFacets, expandStructsInExpression; // transformUtils
 
   bindCsnReference();
 
-  throwWithError(); // reclassify and throw in case of non-configurable errors
+  throwWithAnyError(); // reclassify and throw in case of non-configurable errors
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn')) {
     enrichUniversalCsn(csn, options);
@@ -146,13 +146,13 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   // 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 (especially a2j) to see plain paths in expressions.
-  // If errors are detected, throwWithError() will return from further processing
+  // If errors are detected, throwWithAnyError() will return from further processing
 
   // If this function is ever undefined, we have a bug in our logic.
   // @ts-ignore
   expandStructsInExpression(csn, { drillRef: true });
 
-  throwWithError();
+  throwWithAnyError();
 
   // FIXME: This does something very similar to cloneWithTransformations -> refactor?
   const transformCsn = transformUtils.transformModel;
@@ -167,7 +167,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   if(doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
-    expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithError});
+    expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithAnyError});
     bindCsnReference();
   }
 
@@ -353,7 +353,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   if(doA2J)
     flattening.removeLeadingSelf(csn);
 
-  throwWithError();
+  throwWithAnyError();
 
   timetrace.stop();
 
@@ -381,7 +381,22 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     // Set when we turn UUID into String, checked during generateDraftForHana
     '$renamed': killProp,
     // Set when we remove .key from temporal things, used in localized.js
-    '$key': killProp
+    '$key': killProp,
+    // We need .elements easily for rendering - otherwise we have to compute it then
+    // Does not fit in the "killers" theme - TODO: Find a better place
+    SET: (parent, prop, SET) => {
+      if(!SET.elements) {
+        const stack = [parent];
+        while(stack.length > 0) {
+          const query = stack.pop();
+
+          if(query.SET)
+            stack.push(query.SET.args[0]);
+          else if(query.SELECT)
+            setProp(SET, 'elements', query.SELECT.elements);
+        }
+      }
+    }
   }
 
   applyTransformations(csn, killers, [], { skipIgnore: false});
@@ -393,7 +408,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
   /* ----------------------------------- Functions start here -----------------------------------------------*/
 
   function bindCsnReference(){
-    ({ error, warning, info, message, throwWithError } = makeMessageFunction(csn, options, moduleName));
+    ({ error, warning, info, message, throwWithAnyError } = makeMessageFunction(csn, options, moduleName));
     ({ artifactRef, inspectRef, effectiveType, getFinalBaseType, get$combined } = getUtils(csn));
     ({ addDefaultTypeFacets, expandStructsInExpression } = transformUtils.getTransformers(csn, options, pathDelimiter));
   }
@@ -448,7 +463,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
                 // get$combined also includes elements which are part of "excluding {}"
                 // this shouldn't be an issue here, as such references get rejected
                 const elementsOfQuerySources = get$combined(query);
-                Object.entries(elementsOfQuerySources).forEach(([id, element]) => {
+                forEach(elementsOfQuerySources, (id, element) => {
                   // if the ref points to an element which is not explicitly exposed in the column list,
                   // but through the '*' operator -> replace the $projection / $self with the correct source entity
                   if(id === columnToReplace)
@@ -458,7 +473,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
               // No implicit CAST in on-condition
               if(replaceWith && replaceWith.cast) {
-                const clone = cloneCsn(replaceWith, options);
+                const clone = cloneCsnNonDict(replaceWith, options);
                 delete clone.cast;
                 return clone;
               }
@@ -475,10 +490,14 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
     if (!artifact._ignore) {
       // Do things specific for entities and views (pass 2)
       if ((artifact.kind === 'entity') && artifact.query) {
-        forAllQueries(artifact.query, (q, p) => {
-          transformEntityOrViewPass2(q, artifact, artifactName, p)
-          replaceAssociationsInGroupByOrderBy(q, options, inspectRef, error, p);
-        }, [ 'definitions', artifactName, 'query' ]);
+        const process = (parent, prop, query, path) => {
+          transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop))
+          replaceAssociationsInGroupByOrderBy(parent, options, inspectRef, error, path.concat(prop));
+          return query;
+        }
+        applyTransformationsOnNonDictionary(csn.definitions, artifactName, {
+          SELECT: process
+        }, {}, [ 'definitions']);
       }
     }
   }
@@ -618,7 +637,7 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
 
   function handleAssocToJoins() {
     // With flattening errors, it makes little sense to continue.
-    throwWithError();
+    throwWithAnyError();
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
     // simply make it invisible and copy it over to the result csn
     forEachDefinition(csn, art => art.technicalConfig && setProp(art, 'technicalConfig', art.technicalConfig));
@@ -998,24 +1017,22 @@ function transformForHanaWithCsn(inputModel, options, moduleName) {
       // (which can currently only be 'positiveInteger') and (optional) the value is in a given range
       function checkTypeParamValue(node, paramName, range = null, path = null) {
         const paramValue = node[paramName];
-        if (paramValue == undefined) {
+        if (paramValue === undefined || paramValue === null) {
           if(options.toSql || artifact.query || !['cds.Binary','cds.hana.BINARY', 'cds.hana.NCHAR','cds.hana.CHAR'].includes(node.type)) {
             return true;
           } else {
-            return error('missing-type-parameter', path, { name: paramName, id: node.type, $reviewed: false });
+            return error('type-missing-argument', path, { name: paramName, id: node.type, $reviewed: false });
           }
         }
         if (range) {
           if (isMaxParameterLengthRestricted(node.type) && range.max && paramValue > range.max) {
-            error(null, path,
-              { prop: paramName, type: node.type, number: range.max, $reviewed: false },
-              'Expecting parameter $(PROP) for type $(TYPE) to not exceed $(NUMBER)');
+            error('type-unexpected-argument', path,
+              { '#': 'max', prop: paramName, type: node.type, number: range.max, $reviewed: false });
             return false;
           }
           if (range.min && paramValue < range.min) {
-            error(null, path,
-              { prop: paramName, type: node.type, number: range.min, $reviewed: false },
-              'Expecting parameter $(PROP) for type $(TYPE) to be greater than or equal to $(NUMBER)');
+            error('type-unexpected-argument', path,
+              { '#': 'min', prop: paramName, type: node.type, number: range.min, $reviewed: false });
             return false;
           }
         }

package/lib/transform/forOdataNew.js

@@ -4,7 +4,7 @@ const { makeMessageFunction } = require('../base/messages');
 const { isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const transformUtils = require('./transformUtilsNew');
 const { getUtils,
-        cloneCsn,
+        cloneCsnNonDict,
         forEachDefinition,
         forEachMemberRecursively,
         applyTransformationsOnNonDictionary,
@@ -17,14 +17,12 @@ const { getUtils,
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { isArtifactInSomeService, isLocalizedArtifactInService } = require('./odata/utils');
-const ReferenceFlattener = require('./odata/referenceFlattener');
-const { flattenCSN } = require('./odata/structureFlattener');
-const generateForeignKeys = require('./odata/generateForeignKeyElements');
-const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssociations');
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const { timetrace } = require('../utils/timetrace');
-const { attachPath } = require('./odata/attachPath');
 const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
+const flattening = require('./db/flattening');
+const associations = require('./db/associations')
+const expansion = require('./db/expansion');
 const generateDrafts = require('./draft/odata');
 
 const { addLocalizationViews } = require('./localized');
@@ -74,10 +72,10 @@ module.exports = { transform4odataWithCsn };
 function transform4odataWithCsn(inputModel, options) {
   timetrace.start('OData transformation');
   // copy the model as we don't want to change the input model
-  let csn = cloneCsn(inputModel, options);
+  let csn = cloneCsnNonDict(inputModel, options);
 
-  const { message, error, warning, info, throwWithError } = makeMessageFunction(csn, options, 'for.odata');
-  throwWithError();
+  const { message, error, warning, info, throwWithAnyError } = makeMessageFunction(csn, options, 'for.odata');
+  throwWithAnyError();
 
   // the new transformer works only with new CSN
   checkCSNVersion(csn, options);
@@ -97,7 +95,6 @@ function transform4odataWithCsn(inputModel, options) {
     getServiceName,
     isAssocOrComposition,
     isAssociation,
-    isStructured,
     inspectRef,
     artifactRef,
     effectiveType,
@@ -127,13 +124,13 @@ function transform4odataWithCsn(inputModel, options) {
 
   addLocalizationViews(csn, options, acceptLocalizedView);
 
-  validate.forOdata(csn, {
+  const cleanup = validate.forOdata(csn, {
     message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
   });
 
 
   // Throw exception in case of errors
-  throwWithError();
+  throwWithAnyError();
 
   // Semantic checks before flattening regarding temporal data
   // TODO: Move in the validator
@@ -155,35 +152,38 @@ function transform4odataWithCsn(inputModel, options) {
   // 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 (especially a2j) to see plain paths in expressions.
-  // If errors are detected, throwWithError() will return from further processing
+  // If errors are detected, throwWithAnyError() will return from further processing
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
-  // handles reference flattening
-  let referenceFlattener = new ReferenceFlattener();
-  referenceFlattener.resolveAllReferences(csn, inspectRef, isStructured);
-  attachPath(csn);
-
-  referenceFlattener.applyAliasesInOnCond(csn, inspectRef);
-
   if (!structuredOData) {
-    // flatten structures
-    // @ts-ignore
-    flattenCSN(csn, csnUtils, options, referenceFlattener, error, isExternalServiceMember);
-    // flatten references
-    referenceFlattener.flattenAllReferences(csn);
+    expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, { skipArtifact: isExternalServiceMember });
+    const resolved = new WeakMap();
+    // No refs with struct-steps exist anymore
+    flattening.flattenAllStructStepsInRefs(csn, options, 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, resolved, '_',
+      { skip: [ 'action', 'aspect', 'event', 'function', 'type'], skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
+    // No structured elements exists anymore
+    flattening.flattenElements(csn, options, '_', error,
+      { 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
   }
 
-  // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
-  throwWithError();
+  // TODO: add the generated foreign keys to the columns when we are in a view
+  // see db/views.js::addForeignKeysToColumns
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, '_', !structuredOData, { skipArtifact: isExternalServiceMember });
 
-  // Process associations
-  // 1. In case we generate flat mode, expand the structured foreign keys.
-  // This logic rewrites the 'ref' for such keys with the corresponding flattened
-  // elements.
-  if (!structuredOData)
-    expandStructKeysInAssociations(csn, referenceFlattener, csnUtils, isExternalServiceMember);
-  // 2. generate foreign keys for managed associations
-  generateForeignKeys(csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember);
+  // Allow using managed associations as steps in on-conditions to access their fks
+  // To be done after handleManagedAssociationsAndCreateForeignKeys,
+  // since then the foreign keys of the managed assocs are part of the elements
+  if(!structuredOData)
+    forEachDefinition(csn, associations.getManagedAssocStepsInOnConditionFinalizer(csn, '_'));
+
+  // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
+  throwWithAnyError();
 
   // Apply default type facets as set by options
   // Flatten on-conditions in unmanaged associations
@@ -207,22 +207,23 @@ function transform4odataWithCsn(inputModel, options) {
   generateDrafts(csn, options, services)
 
   // Deal with all kind of annotations manipulations here
+  const skipPersNameKinds = {'service':1, 'context':1, 'namespace':1, 'annotation':1, 'action':1, 'function':1};
   forEachDefinition(csn, (def, defName) => {
     // Resolve annotation shorthands for entities, types, annotations, ...
     renameShorthandAnnotations(def);
 
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
-    if (options.toOdata.names && !['service', 'context', 'namespace', 'annotation', 'action', 'function'].includes(def.kind))
+    if (options.toOdata.names && !(def.kind in skipPersNameKinds))
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.toOdata.names, csn);
 
-    forEachMemberRecursively(def, (member, memberName, propertyName, path) => {
+    forEachMemberRecursively(def, (member, memberName, propertyName) => {
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested
       // Only these are actually required and don't annotate virtual elements in entities or types
       // as they have no DB representation (although in views)
-      if (options.toOdata.names && typeof member === 'object' && !['action', 'function'].includes(member.kind) && propertyName !== 'enum' && (!member.virtual || def.query)) {
+      if (options.toOdata.names && typeof member === 'object' && !(member.kind === 'action' || member.kind === 'function') && propertyName !== 'enum' && (!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(referenceFlattener.getElementNameWithDots(path) || memberName, options.toOdata.names);
+        member['@cds.persistence.name'] = getElementDatabaseNameOf(member._flatElementNameWithDots || memberName, options.toOdata.names);
       }
 
       // Mark fields with @odata.on.insert/update as @Core.Computed
@@ -252,9 +253,9 @@ function transform4odataWithCsn(inputModel, options) {
   }, { skipArtifact: isExternalServiceMember })
 
   // Throw exception in case of errors
-  throwWithError();
-
-  if (options.testMode) csn = cloneCsn(csn, options);   // sort, keep hidden properties
+  throwWithAnyError();
+  cleanup();
+  if (options.testMode) csn = cloneCsnNonDict(csn, options);   // sort, keep hidden properties
   timetrace.stop();
   return csn;
 

package/lib/transform/localized.js

@@ -3,10 +3,10 @@
 const { makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
 const { hasErrors } = require('../base/messages');
-const { cloneCsnDictionary } = require('../model/csnUtils');
+const { cloneCsnDictionary, applyDefinitionAnnotationsFromExtensions} = require('../model/csnUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
-  cloneCsn,
+  cloneCsnNonDict,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
@@ -86,6 +86,12 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
   forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
 
+  // In case that the user tried to annotate `localized.*` artifacts, apply them.
+  applyDefinitionAnnotationsFromExtensions(csn, {
+    overwrite: true,
+    filter: (name) => name.startsWith('localized.')
+  });
+
   sortCsnDefinitionsForTests(csn, options);
   return csn;
 
@@ -141,9 +147,8 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     else
       view = createLocalizedViewForEntity(art, artName, textElements);
 
+    copyPersistenceAnnotations(view, art);
     csn.definitions[viewName] = view;
-
-    copyPersistenceAnnotations(csn.definitions[viewName], art);
   }
 
   /**
@@ -245,9 +250,9 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     };
 
     if (view.query)
-      convenienceView.query = cloneCsn(view.query, options);
+      convenienceView.query = cloneCsnNonDict(view.query, options);
     else if (view.projection)
-      convenienceView.projection = cloneCsn(view.projection, options);
+      convenienceView.projection = cloneCsnNonDict(view.projection, options);
 
     convenienceView.elements = cloneCsnDictionary(view.elements, options);
     convenienceView[_isViewForView] = true;
@@ -549,7 +554,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     if (!obj || typeof obj !== 'object' || Array.isArray(obj))
       return;
 
-    for (const prop of [ 'ref', 'target', 'on' ]) {
+    for (const prop of [ 'ref', 'target' ]) {
       const val = obj[prop];
       if (prop === 'ref') {
         rewriteRefToLocalized(obj);

package/lib/transform/odata/toFinalBaseType.js

@@ -2,7 +2,7 @@
 
 const {
   forEachDefinition, forEachMemberRecursively,
-  isBuiltinType, cloneCsnDictionary, cloneCsn,
+  isBuiltinType, cloneCsnDictionary, cloneCsnNonDict,
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
@@ -97,7 +97,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
           // type T: S; --> Integer;
           // type S: X; --> Integer;
           // type X: Integer;
-          // 
+          //
           // type A: B; -> {...}
           // type B: C; -> { ... }
           // type C { .... };
@@ -120,7 +120,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
           //  type T: S; --> Integer;
           //  type S: X; --> Integer;
           //  type X: Integer;
-          //  
+          //
           //  type {
           //    struct_elt: many A; ---> stays the same
           //    scalar_elt: T; ---> Integer;
@@ -162,7 +162,7 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
       // do the clone only if really needed
       if((finalType.items && !node.items) ||
          (finalType.elements && !node.elements))
-        clone = cloneCsn({ definitions: { 'TypeDef': finalType } }, options);
+        clone = cloneCsnNonDict({ definitions: { 'TypeDef': finalType } }, options);
       if (finalType.items) {
         delete node.type;
         if(!node.items)
@@ -193,4 +193,4 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
   }
 }
 
-module.exports = expandToFinalBaseType;
+module.exports = expandToFinalBaseType;