@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/transform/draft/db.js

@@ -18,7 +18,7 @@ const booleanBuiltin = 'cds.Boolean';
  * @param {string} pathDelimiter
  * @param {object} messageFunctions
  */
-function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
+function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   const draftSuffix = '.drafts';
   // All services of the model - needed for drafts
   const allServices = getServiceNames(csn);
@@ -38,7 +38,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
-  function generateDraft(artifact, artifactName) {
+  function generateDraft( artifact, artifactName ) {
     if ((artifact.kind === 'entity') &&
         hasAnnotationValue(artifact, draftAnnotation) &&
         isPartOfService(artifactName)) {
@@ -69,7 +69,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {CSN.Artifact} rootArtifact root artifact where composition traversal started.
    * @param {object} draftNodes Dictionary of artifacts
    */
-  function collectDraftNodesInto(artifact, artifactName, rootArtifact, draftNodes) {
+  function collectDraftNodesInto( artifact, artifactName, rootArtifact, draftNodes ) {
     // Collect the artifact itself
     draftNodes[artifactName] = artifact;
     // Follow all composition targets in elements of 'artifact'
@@ -108,7 +108,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {string} artifactName
    * @param {string} draftRootName
    */
-  function generateDraftForHana(artifact, artifactName, draftRootName) {
+  function generateDraftForHana( artifact, artifactName, draftRootName ) {
     // Sanity check
     if (!isPartOfService(artifactName))
       throw new ModelError(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
@@ -234,7 +234,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
      * @param {CSN.Association} association Assoc to check
      * @returns {object}
      */
-    function getDraftUUIDKey(association) {
+    function getDraftUUIDKey( association ) {
       if (association.keys) {
         const filtered = association.keys.filter(o => (o.ref && !o.as && o.ref.length === 1 && o.ref[0] === 'DraftUUID') || (o.as && o.as === 'DraftUUID'));
         if (filtered.length === 1)
@@ -253,7 +253,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
      * @param {object} obj Any object with at least "ref"
      * @returns {string}
      */
-    function getNameForRef(obj) {
+    function getNameForRef( obj ) {
       if (obj.as)
         return obj.as;
 
@@ -285,7 +285,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {CSN.Artifact} artifact
    * @param {CSN.Artifact[]} draftNodes
    */
-  function redirectDraftTargets(artifact, draftNodes) {
+  function redirectDraftTargets( artifact, draftNodes ) {
     for (const elemName in artifact.elements) {
       const elem = artifact.elements[elemName];
       if (elem.target) {
@@ -310,7 +310,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
      * @param {string} draftNodeName
      * @returns {object} Object with shadowTarget: definition and shadowTargetName: Name of the definition
      */
-    function getDraftShadowEntityFor(draftNode, draftNodeName) {
+    function getDraftShadowEntityFor( draftNode, draftNodeName ) {
       // Sanity check
       if (!draftNodes[draftNodeName])
         throw new ModelError(`Not a draft node: ${draftNodeName}`);
@@ -325,7 +325,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {string} artifactName Absolute name of the artifact
    * @returns {boolean}
    */
-  function isPartOfService(artifactName) {
+  function isPartOfService( artifactName ) {
     for (const serviceName of allServices) {
       if (artifactName.startsWith(`${serviceName}.`))
         return true;
@@ -340,7 +340,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {string} artifactName Absolute name of the artifact
    * @returns {false|string} Name of the service or false if no match is found.
    */
-  function getMatchingService(artifactName) {
+  function getMatchingService( artifactName ) {
     const matches = [];
     for (const serviceName of allServices) {
       if (artifactName.startsWith(`${serviceName}.`))

package/lib/transform/draft/odata.js

@@ -23,7 +23,7 @@ const { makeMessageFunction } = require('../../base/messages');
  * @todo should be done by the compiler - Check associations for valid foreign keys
  * @todo check if needed at all: Remove '$projection' from paths in the element's ON-condition
  */
-function generateDrafts(csn, options, services) {
+function generateDrafts( csn, options, services ) {
   const {
     createForeignKeyElement,
     createAndAddDraftAdminDataProjection, createScalarElement,
@@ -73,7 +73,7 @@ function generateDrafts(csn, options, services) {
    * @param {string} artifactName
    * @param {CSN.Artifact} rootArtifact artifact where composition traversal started
    */
-  function generateDraftForOdata(artifact, artifactName, rootArtifact) {
+  function generateDraftForOdata( artifact, artifactName, rootArtifact ) {
     // Sanity check
     // @ts-ignore
     if (!isArtifactInSomeService(artifactName, services))

package/lib/transform/forOdataNew.js

@@ -10,8 +10,8 @@ const { cloneCsnNonDict,
         getArtifactDatabaseNameOf,
         getElementDatabaseNameOf,
         isAspect,
-        isBuiltinType,
         getServiceNames,
+        forEachGeneric,
       } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
@@ -165,11 +165,11 @@ function transform4odataWithCsn(inputModel, options) {
     // 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'], 
+      { 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'], 
+      { 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
@@ -213,14 +213,14 @@ function transform4odataWithCsn(inputModel, options) {
   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, ['definitions', defName ]);
+    renameShorthandAnnotations(def);
 
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
     if (options.sqlMapping && !(def.kind in skipPersNameKinds))
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana'); // hana to allow naming mode "hdbcds"
 
-    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)
@@ -233,7 +233,7 @@ function transform4odataWithCsn(inputModel, options) {
       annotateCoreComputed(member);
 
       // Resolve annotation shorthands for elements, actions, action parameters
-      renameShorthandAnnotations(member, path);
+      renameShorthandAnnotations(member);
 
       // - If the association target is annotated with @cds.odata.valuelist, annotate the
       //      association with @Common.ValueList.viaAssociation
@@ -255,11 +255,15 @@ function transform4odataWithCsn(inputModel, options) {
     }
   }, { skipArtifact: isExternalServiceMember })
 
+  if(isBetaEnabled(options, 'odataTerms')) {
+    forEachGeneric(csn, 'vocabularies', renameShorthandAnnotations);
+  }
+
   // Throw exception in case of errors
   throwWithAnyError();
   cleanup();
   if (options.testMode) csn = cloneCsnNonDict(csn, options);   // sort, keep hidden properties
-  timetrace.stop();
+  timetrace.stop('OData transformation');
   return csn;
 
   // TODO: Move this to checks?
@@ -298,7 +302,7 @@ function transform4odataWithCsn(inputModel, options) {
 
   // Rename shorthand annotations within artifact or element 'node' according to a builtin
   // list.
-  function renameShorthandAnnotations(node, path) {
+  function renameShorthandAnnotations(node) {
     // FIXME: Verify this list - are they all still required? Do we need any more?
     const mappings = {
       '@label': '@Common.Label',
@@ -362,38 +366,6 @@ function transform4odataWithCsn(inputModel, options) {
           setAnnotation(node, '@Validation.Minimum', node['@assert.range'][0]);
           setAnnotation(node, '@Validation.Maximum', node['@assert.range'][1]);
         }
-        // for enums @assert.range changes into a boolean annotation
-        else if (node[name] === true) {
-          let typeDef = node;
-          if(!node.enum && node.type && !isBuiltinType(node.type))
-            typeDef = csn.definitions[node.type];
-          if(typeDef.enum) {
-            const enumValue = [];
-            for(const enumSymbol in typeDef.enum) {
-              const enumSymbolDef = typeDef.enum[enumSymbol];
-              if(enumSymbolDef.val === null)
-                info('odata-enum-value-type', path,
-                  {name: enumSymbol, value: null, anno: '@Valiation.AllowedValues' },
-                  'Value $(VALUE) for enum element $(NAME) not added to $(ANNO)');
-              else {
-                const result = { '@Core.SymbolicName': enumSymbol };
-                if (enumSymbolDef.val !== undefined)
-                  result.Value = enumSymbolDef.val;
-                else if (node.type && node.type === 'cds.String')
-                  // the symbol is used as value only for type 'cds.String'
-                  result.Value = enumSymbol;
-                // Can't rely that @description has already been renamed to @Core.Description
-                // Eval description according to precedence (doc comment must be considered already in Odata transformer
-                // as in contrast to the other doc commments as it is used to annotate the @Validation.AllowedValues)
-                const desc = enumSymbolDef['@Core.Description'] || enumSymbolDef['@description'] || enumSymbolDef.doc;
-                if (desc)
-                  result['@Core.Description'] = desc;
-                enumValue.push(result);
-              }
-            }
-            setAnnotation(node, '@Validation.AllowedValues', enumValue);
-          }
-        }
       }
     });
   }

package/lib/transform/forRelationalDB.js

@@ -4,7 +4,7 @@ const { setProp, isBetaEnabled } = require('../base/model');
 const { getUtils, cloneCsnNonDict,
         forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
-        isAspect, walkCsnPath,
+        isAspect, walkCsnPath, isPersistedOnDatabase,
       } = require('../model/csnUtils');
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtilsNew');
@@ -29,7 +29,7 @@ const { getViewTransformer } = require('./db/views');
 const cdsPersistence = require('./db/cdsPersistence');
 const temporal = require('./db/temporal');
 const associations = require('./db/associations')
-const { ModelError } = require("../base/error");
+const { ModelError } = require('../base/error');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -103,8 +103,11 @@ function forEachDefinition(csn, cb) {
 function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
+
+  timetrace.start('Clone CSN');
   /** @type {CSN.Model} */
   let csn = cloneCsnNonDict(inputModel, options);
+  timetrace.stop('Clone CSN');
 
   checkCSNVersion(csn, options);
 
@@ -130,10 +133,12 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   if (!doA2J)
     forEachDefinition(csn, handleMixinOnConditions);
 
+  timetrace.start('Validate');
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
     message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, isAspect
   });
+  timetrace.stop('Validate');
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
   handleExists(csn, options, error);
@@ -153,9 +158,11 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   const transformCsn = transformUtils.transformModel;
 
 
+  timetrace.start('temporal');
   // (001) Add a temporal where condition to views where applicable before assoc2join
   //       assoc2join eventually rewrites the table aliases
   forEachDefinition(csn, temporal.getViewDecorator(csn, {info}));
+  timetrace.stop('temporal');
 
   // check unique constraints - further processing is done in rewriteUniqueConstraints
   assertUnique.prepare(csn, options, error, info);
@@ -227,6 +234,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     cloneWithTransformations,
   } = csnUtils;
 
+  timetrace.start('Transform CSN')
+
   // (000) Rename primitive types, make UUID a String
   transformCsn(csn, {
     type: (val, node, key) => {
@@ -251,7 +260,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   forEachDefinition(csn, temporal.getAnnotationHandler(csn, options, pathDelimiter, {error}));
 
   // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
-  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, { allowArtifact: artifact => (artifact.kind === 'entity') });
+  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
 
   doA2J && forEachDefinition(csn, flattenIndexes);
   // Managed associations get an on-condition - in views and entities
@@ -278,9 +287,9 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     addLocalizationViews(csn, options);
 
   !doA2J && forEachDefinition(csn, (definition, artName, prop, path) => {
-    if (definition.query) {
+    if (definition.query && isPersistedOnDatabase(definition)) {
       // reject managed association and structure publishing for to-hdbcds.hdbcds
-      const that = { csnUtils: getUtils(csn), options, error };
+      const that = { csnUtils, options, error };
       rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path)
     }
   });
@@ -351,8 +360,6 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   throwWithAnyError();
 
-  timetrace.stop();
-
   function killProp(parent, prop){
     delete parent[prop];
   }
@@ -408,6 +415,9 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   redoProjections.forEach(fn => fn());
 
+  timetrace.stop('Transform CSN');
+  timetrace.stop('HANA transformation');
+
   return csn;
 
   /* ----------------------------------- Functions start here -----------------------------------------------*/

package/lib/transform/localized.js

@@ -724,8 +724,8 @@ function checkExistingLocalizationViews(csn, options, messageFunctions) {
       if (!def.query && !def.projection) {
         if (!name.endsWith('.texts')) {
           hasNonViews = true;
-          messageFunctions.error('reserved-namespace-localized', ['definitions', name], {},
-            'The namespace "localized" is reserved for localization views');
+          messageFunctions.error('reserved-namespace-localized', ['definitions', name], { name: 'localized' },
+            'The namespace $(NAME) is reserved for localization views');
         }
       } else if (!hasExistingViews) {
         hasExistingViews = true;

package/lib/transform/odata/toFinalBaseType.js

@@ -1,7 +1,8 @@
 'use strict';
 
+const { isBetaEnabled } = require('../../base/model');
 const {
-  forEachDefinition, forEachMemberRecursively,
+  forEachDefinition, forEachGeneric, forEachMemberRecursively,
   isBuiltinType, cloneCsnDictionary, cloneCsnNonDict,
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
@@ -22,32 +23,33 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     expandToFinalBaseType(def.items, defName);
     expandToFinalBaseType(def.returns, defName);
     expandToFinalBaseType(def.returns && def.returns.items, defName);
-
-    // If the definition('def' variable) is a type definition and the assigned type of this very same definition('def' variable)
-    // is structured type, e.g.:
-    //
-    // type Struct1 {
-    //    a : Integer;
-    //    b : Integer;
-    //  };
-    // type Struct2: Struct1;
-    // after compilation the csn looks like this:
-    // ...
-    // "S.Struct1": {
-    //   "kind": "type",
-    //   "elements": {
-    //     "a": { "type": "cds.Integer" },
-    //     "b": { "type": "cds.Integer" }
-    //   } },
-    // "S.Struct2": {
-    //   "kind": "type",
-    //   "type": "S.Struct1",
-    //   "elements": {
-    //     "a": { "type": "cds.Integer" },
-    //     "b": { "type": "cds.Integer" }
-    //   } } ...
-    //
-    // "S.Struct2" should looks just like "S.Struct1" => the "type": "S.Struct1" property has to be removed
+    /*
+      If the definition('def' variable) is a type definition and the assigned type of this very same definition('def' variable)
+      is structured type, e.g.:
+      
+      type Struct1 {
+        a : Integer;
+        b : Integer;
+      };
+      type Struct2: Struct1;
+      after compilation the csn looks like this:
+      ...
+      "S.Struct1": {
+        "kind": "type",
+        "elements": {
+          "a": { "type": "cds.Integer" },
+          "b": { "type": "cds.Integer" }
+        } },
+      "S.Struct2": {
+        "kind": "type",
+        "type": "S.Struct1",
+        "elements": {
+          "a": { "type": "cds.Integer" },
+          "b": { "type": "cds.Integer" }
+        } } ...
+      
+      "S.Struct2" should looks just like "S.Struct1" => the "type": "S.Struct1" property has to be removed
+    */
     if (def.kind === 'type' && def.type && !isBuiltinType(def.type) && !def.type.ref) {
       // elements are already there -> do not show the type
       delete def.type;
@@ -62,6 +64,18 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     }
   }, { skipArtifact: isExternalServiceMember });
 
+  if(isBetaEnabled(options, 'odataTerms')) {
+    forEachGeneric(csn, 'vocabularies', (def, defName) => {
+      forEachMemberRecursively(def, (member) => {
+        expandToFinalBaseType(member, defName);
+        expandToFinalBaseType(member.items, defName);
+
+      }, ['vocabularies', defName]);
+
+      expandToFinalBaseType(def, defName);
+      expandToFinalBaseType(def.items, defName);
+    }, [], { skipArtifact: isExternalServiceMember });
+  }
   // In case we have in the model something like:
   // type Foo: array of Bar; type Bar: { qux: Integer };
   // In the type Foo we expand the first level of elements of the items like we have in CDL this: