@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/transform/forOdataNew.js

@@ -7,7 +7,7 @@ const { getUtils,
         cloneCsn,
         forEachDefinition,
         forEachMemberRecursively,
-        forEachRef,
+        applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf,
         getElementDatabaseNameOf,
         isAspect,
@@ -16,7 +16,7 @@ const { getUtils,
       } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
-const { isArtifactInSomeService, getServiceOfArtifact, isLocalizedArtifactInService } = require('./odata/utils');
+const { isArtifactInSomeService, isLocalizedArtifactInService } = require('./odata/utils');
 const ReferenceFlattener = require('./odata/referenceFlattener');
 const { flattenCSN } = require('./odata/structureFlattener');
 const generateForeignKeys = require('./odata/generateForeignKeyElements');
@@ -24,7 +24,8 @@ const expandStructKeysInAssociations = require('./odata/expandStructKeysInAssoci
 const expandToFinalBaseType = require('./odata/toFinalBaseType');
 const { timetrace } = require('../utils/timetrace');
 const { attachPath } = require('./odata/attachPath');
-const enrichUniversalCsn = require('./universalCsnEnricher');
+const enrichUniversalCsn = require('./universalCsn/universalCsnEnricher');
+const generateDrafts = require('./draft/odata');
 
 const { addLocalizationViews } = require('./localized');
 
@@ -75,7 +76,7 @@ function transform4odataWithCsn(inputModel, options) {
   // copy the model as we don't want to change the input model
   let csn = cloneCsn(inputModel, options);
 
-  const { error, warning, info, throwWithError } = makeMessageFunction(csn, options, 'for.odata');
+  const { message, error, warning, info, throwWithError } = makeMessageFunction(csn, options, 'for.odata');
   throwWithError();
 
   // the new transformer works only with new CSN
@@ -84,22 +85,16 @@ function transform4odataWithCsn(inputModel, options) {
   const transformers = transformUtils.getTransformers(csn, options, '_');
   const {
     addDefaultTypeFacets,
-    createForeignKeyElement,
-    createAndAddDraftAdminDataProjection, createScalarElement,
-    createAssociationElement, createAssociationPathComparison,
-    addElement, createAction, assignAction,
     extractValidFromToKeyElement,
     checkAssignment, checkMultipleAssignments,
-    recurseElements, setAnnotation, resetAnnotation, renameAnnotation,
+    recurseElements, setAnnotation, renameAnnotation,
     expandStructsInExpression
   } = transformers;
 
   const csnUtils = getUtils(csn);
   const {
     getCsnDef,
-    getFinalType,
     getServiceName,
-    hasAnnotationValue,
     isAssocOrComposition,
     isAssociation,
     isStructured,
@@ -133,7 +128,7 @@ function transform4odataWithCsn(inputModel, options) {
   addLocalizationViews(csn, options, acceptLocalizedView);
 
   validate.forOdata(csn, {
-    error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csn, options, csnUtils, services, getFinalBaseType, isAspect, isExternalServiceMember
   });
 
 
@@ -191,10 +186,10 @@ function transform4odataWithCsn(inputModel, options) {
   generateForeignKeys(csn, options, referenceFlattener, csnUtils, error, isExternalServiceMember);
 
   // Apply default type facets as set by options
-  // Flatten on-conditions in unmanaged associations 
+  // Flatten on-conditions in unmanaged associations
   /* FIXME (HJB): Is this comment still correct? processOnCond only strips $self
                   We should not remove $self prefixes in structured OData to not
-                  interfer with path resolution 
+                  interfer with path resolution
   */
   // This must be done before all the draft logic as all
   // composition targets are annotated with @odata.draft.enabled in this step
@@ -209,19 +204,7 @@ function transform4odataWithCsn(inputModel, options) {
   //        - structured types must not contain associations for OData V2
   // - Element must not be an 'array of' for OData V2 TODO: move to the validator
   // - Perform checks for exposed non-abstract entities and views - check media type and key-ness
-  let visitedArtifacts = Object.create(null);
-  forEachDefinition(csn, (def, defName) => {
-    if (def.kind === 'entity' || def.kind === 'view') {
-      // Generate artificial draft fields if requested
-      if (def['@odata.draft.enabled']) {
-        // Ignore if not part of a service
-        if (isArtifactInSomeService(defName, services)) {
-          generateDraftForOdata(def, defName, def, visitedArtifacts);
-        }
-      }
-    }
-    visitedArtifacts[defName] = true;
-  }, { skipArtifact: isExternalServiceMember });
+  generateDrafts(csn, options, services)
 
   // Deal with all kind of annotations manipulations here
   forEachDefinition(csn, (def, defName) => {
@@ -303,8 +286,9 @@ function transform4odataWithCsn(inputModel, options) {
     // If @Core.Computed is explicitly set, don't overwrite it!
     if (node['@Core.Computed'] !== undefined) return;
 
-    // For @odata.on.insert/update, also add @Core.Computed
-    if (node['@odata.on.insert'] || node['@odata.on.update'])
+    // For @odata.on.insert/update,  also add @Core.Computed
+    // @odata.on is deprecated, use @cds.on {update|insert} instead
+    if(['@odata.on.insert', '@odata.on.update', '@cds.on.insert', '@cds.on.update'].some(a => node[a]))
       node['@Core.Computed'] = true;
   }
 
@@ -341,7 +325,7 @@ function transform4odataWithCsn(inputModel, options) {
       // but '@Core.Immutable' for everything else.
       if (!(node['@readonly'] && node['@insertonly'])) {
         if (name === '@readonly' && node[name] !== null) {
-          if (node.kind === 'entity' || node.kind === 'view') {
+          if (node.kind === 'entity') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
@@ -351,7 +335,7 @@ function transform4odataWithCsn(inputModel, options) {
         }
         // @insertonly is effective on entities/queries only
         else if (name === '@insertonly' && node[name] !== null) {
-          if (node.kind === 'entity' || node.kind === 'view') {
+          if (node.kind === 'entity') {
             setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
             setAnnotation(node, '@Capabilities.ReadRestrictions.Readable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
@@ -422,151 +406,14 @@ function transform4odataWithCsn(inputModel, options) {
     // removes leading $self in on-conditions's references
     function removeLeadingDollarSelfInOnCondition(assoc) {
       if (!assoc.on) return; // nothing to do
-      forEachRef(assoc, (ref, node) => {
-        // remove leading $self when at the begining of a ref
-        if (ref.length > 1 && ref[0] === '$self')
-          node.ref.splice(0, 1);
-      });
-    }
-  }
-
-  // Generate all that is required in ODATA for draft enablement of 'artifact' into the artifact,
-  // into its transitively reachable composition targets, and into the model.
-  // 'rootArtifact' is the root artifact where composition traversal started.
-
-  // Constraints
-  // Draft Root: Exactly one PK of type UUID
-  // Draft Node: One PK of type UUID + 0..1 PK of another type
-  // Draft Node: Must not be reachable from multiple draft roots
-  function generateDraftForOdata(artifact, artifactName, rootArtifact, visitedArtifacts) {
-    // Sanity check
-    // @ts-ignore
-    if (!isArtifactInSomeService(artifactName, services)) {
-      throw new Error('Expecting artifact to be part of a service: ' + JSON.stringify(artifact));
-    }
-    // Nothing to do if already draft-enabled (composition traversal may have circles)
-    if ((artifact['@Common.DraftRoot.PreparationAction'] || artifact['@Common.DraftNode.PreparationAction'])
-      && artifact.actions && artifact.actions.draftPrepare) {
-      return;
-    }
-
-    // Generate the DraftAdministrativeData projection into the service, unless there is already one
-    // @ts-ignore
-    let draftAdminDataProjectionName = `${getServiceOfArtifact(artifactName, services)}.DraftAdministrativeData`;
-    let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
-    if (!draftAdminDataProjection) {
-      // @ts-ignore
-      draftAdminDataProjection = createAndAddDraftAdminDataProjection(getServiceOfArtifact(artifactName, services));
-    }
-    // Report an error if it is not an entity or not what we expect
-    if (draftAdminDataProjection.kind !== 'entity' || !draftAdminDataProjection.elements['DraftUUID']) {
-      error(null, ['definitions', draftAdminDataProjectionName], { name: draftAdminDataProjectionName },
-        `Generated entity $(NAME) conflicts with existing artifact`);
-    }
-    // Generate the annotations describing the draft actions (only draft roots can be activated/edited)
-    if (artifact == rootArtifact) {
-      resetAnnotation(artifact, '@Common.DraftRoot.ActivationAction', 'draftActivate', info, ['definitions', draftAdminDataProjectionName]);
-      resetAnnotation(artifact, '@Common.DraftRoot.EditAction', 'draftEdit', info, ['definitions', draftAdminDataProjectionName]);
-      resetAnnotation(artifact, '@Common.DraftRoot.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
-    } else {
-      resetAnnotation(artifact, '@Common.DraftNode.PreparationAction', 'draftPrepare', info, ['definitions', draftAdminDataProjectionName]);
-    }
-
-    artifact.elements && Object.values(artifact.elements).forEach( elem => {
-      // Make all non-key elements nullable
-      if (elem.notNull && elem.key !== true) {
-        delete elem.notNull;
-      }
-    });
-    // Generate the additional elements into the draft-enabled artifact
-
-    // key IsActiveEntity : Boolean default true
-    let isActiveEntity = createScalarElement('IsActiveEntity', 'cds.Boolean', true, true, false);
-    isActiveEntity.IsActiveEntity['@UI.Hidden'] = true;
-    addElement(isActiveEntity, artifact, artifactName);
-
-    // HasActiveEntity : Boolean default false
-    let hasActiveEntity = createScalarElement('HasActiveEntity', 'cds.Boolean', false, false, true);
-    hasActiveEntity.HasActiveEntity['@UI.Hidden'] = true;
-    addElement(hasActiveEntity, artifact, artifactName);
-
-    // HasDraftEntity : Boolean default false;
-    let hasDraftEntity = createScalarElement('HasDraftEntity', 'cds.Boolean', false, false, true);
-    hasDraftEntity.HasDraftEntity['@UI.Hidden'] = true;
-    addElement(hasDraftEntity, artifact, artifactName);
-
-    // @odata.contained: true
-    // DraftAdministrativeData : Association to one DraftAdministrativeData;
-    let draftAdministrativeData = createAssociationElement('DraftAdministrativeData', draftAdminDataProjectionName, true);
-    draftAdministrativeData.DraftAdministrativeData.cardinality = { max: 1, };
-    draftAdministrativeData.DraftAdministrativeData['@odata.contained'] = true;
-    draftAdministrativeData.DraftAdministrativeData['@UI.Hidden'] = true;
-    addElement(draftAdministrativeData, artifact, artifactName);
-
-    // Note that we need to do the ODATA transformation steps for managed associations
-    // (foreign key field generation, generatedFieldName) by hand, because the corresponding
-    // transformation steps have already been done on all artifacts when we come here)
-    let uuidDraftKey = draftAdministrativeData.DraftAdministrativeData.keys.filter(key => key.ref && key.ref.length === 1 && key.ref[0] === 'DraftUUID');
-    if (uuidDraftKey && uuidDraftKey[0]) {
-      uuidDraftKey = uuidDraftKey[0]; // filter returns an array, but it has only one element
-      let path = ['definitions', artifactName, 'elements', 'DraftAdministrativeData', 'keys', 0];
-      createForeignKeyElement(draftAdministrativeData.DraftAdministrativeData, 'DraftAdministrativeData', uuidDraftKey, artifact, artifactName, path);
-    }
-    // SiblingEntity : Association to one <artifact> on (... IsActiveEntity unequal, all other key fields equal ...)
-    let siblingEntity = createAssociationElement('SiblingEntity', artifactName, false);
-    siblingEntity.SiblingEntity.cardinality = { max: 1 };
-    addElement(siblingEntity, artifact, artifactName);
-    // ... on SiblingEntity.IsActiveEntity != IsActiveEntity ...
-    siblingEntity.SiblingEntity.on = createAssociationPathComparison('SiblingEntity', 'IsActiveEntity', '!=', 'IsActiveEntity');
-
-    // Iterate elements
-    artifact.elements && Object.entries(artifact.elements).forEach( ([elemName, elem]) => {
-      if (elemName !== 'IsActiveEntity' && elem.key) {
-        // Amend the ON-condition above:
-        // ... and SiblingEntity.<keyfield> = <keyfield> ... (for all key fields except 'IsActiveEntity')
-        let cond = createAssociationPathComparison('SiblingEntity', elemName, '=', elemName);
-        cond.push('and');
-        cond.push(...siblingEntity.SiblingEntity.on);
-        siblingEntity.SiblingEntity.on = cond;
-      }
-
-      // Draft-enable the targets of composition elements (draft nodes), too
-      // TODO rewrite
-      if (elem.target && elem.type && getFinalType(elem.type) === 'cds.Composition') {
-        let draftNode = csn.definitions[elem.target];
-
-        // Ignore if that is our own draft root
-        if (draftNode != rootArtifact) {
-          // Report error when the draft node has @odata.draft.enabled itself
-          if (hasAnnotationValue(draftNode, '@odata.draft.enabled', true)) {
-            error(null, ['definitions', artifactName, 'elements', elemName], 'Composition in draft-enabled entity can\'t lead to another entity with “@odata.draft.enabled”');
-          }
-          // Ignore composition if not part of a service or explicitly draft disabled
-          else if (!getServiceName(elem.target) || hasAnnotationValue(draftNode, '@odata.draft.enabled', false)) {
-            return;
-          }
-          else {
-            // Generate draft stuff into the target
-            generateDraftForOdata(draftNode, elem.target, rootArtifact, visitedArtifacts);
-          }
+      // TODO: Shouldn't this only run on the on-condition and not the whole assoc-node?
+      applyTransformationsOnNonDictionary({ assoc }, 'assoc', {
+        ref: (node, prop, ref) => {
+          // remove leading $self when at the begining of a ref
+          if (ref.length > 1 && ref[0] === '$self')
+            node.ref.splice(0, 1);
         }
-      }
-    });
-
-    // Generate the actions into the draft-enabled artifact (only draft roots can be activated/edited)
-
-    // action draftPrepare (SideEffectsQualifier: String) return <artifact>;
-    let draftPrepare = createAction('draftPrepare', artifactName, 'SideEffectsQualifier', 'cds.String');
-    assignAction(draftPrepare, artifact);
-
-    if (artifact == rootArtifact) {
-      // action draftActivate() return <artifact>;
-      let draftActivate = createAction('draftActivate', artifactName);
-      assignAction(draftActivate, artifact);
-
-      // action draftEdit (PreserveChanges: Boolean) return <artifact>;
-      let draftEdit = createAction('draftEdit', artifactName, 'PreserveChanges', 'cds.Boolean');
-      assignAction(draftEdit, artifact);
+      });
     }
   }
 

package/lib/transform/localized.js

@@ -5,14 +5,12 @@ const { setProp } = require('../base/model');
 const { hasErrors } = require('../base/messages');
 const { cloneCsnDictionary } = require('../model/csnUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
-const { rejectManagedAssociationsAndStructuresForHdbcsNames } = require('../checks/selectItems');
 const {
   cloneCsn,
   forEachDefinition,
   forEachGeneric,
   forAllQueries,
   sortCsnDefinitionsForTests,
-  getUtils,
 } = require('../model/csnUtils');
 
 /**
@@ -50,7 +48,7 @@ const _targetFor = Symbol('_targetFor');
  * We have three kinds of localized convenience views:
  *
  *  1. "direct ones" using coalesce() for the table entities with localized
- *     elements: as projection on the original (created in definer.js)
+ *     elements: as projection on the original (created in extend.js)
  *  2. for table entities with associations to entities which have a localized
  *     convenience views or redirections thereon: as projection on the original
  *  3. for view entities with associations to entities which have a localized
@@ -76,27 +74,17 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
   if (hasErrors(options.messages))
     return csn;
 
-  if (hasExistingLocalizationViews(csn, options))
+  const messageFunctions = makeMessageFunction(csn, options);
+  if (hasExistingLocalizationViews(csn, options, messageFunctions))
     return csn;
 
-  const { info, error } = makeMessageFunction(csn, options);
-
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
 
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
 
-  forEachDefinition(csn, (definition, artName, prop, path) => {
-    cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor)
-    if(definition.query) {
-      // reject managed association and structure publishing for to-hdbcds.hdbcds
-      const that = { csnUtils: getUtils(csn), options, error };
-      rejectManagedAssociationsAndStructuresForHdbcsNames.call(that, definition, path)
-    }
-  });
-
-
+  forEachDefinition(csn, definition => cleanSymbols(definition, _hasLocalizedView, _isViewForEntity, _isViewForView, _targetFor));
 
   sortCsnDefinitionsForTests(csn, options);
   return csn;
@@ -113,7 +101,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
         return;
 
       if (isInLocalizedNamespace(artName))
-        // We already issued a warning for it in warnAboutExistingLocalizationViews()
+        // We already issued a warning for it in hasExistingLocalizationViews()
         return;
 
       const localized = getLocalizedTextElements( artName );
@@ -138,13 +126,13 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
 
     if (csn.definitions[viewName]) {
       // Already exists, skip creation.
-      info( null, artPath, null, 'Convenience view can\'t be created due to conflicting names' );
+      messageFunctions.info( null, artPath, null, 'Convenience view can\'t be created due to conflicting names' );
       return;
     }
 
     art[_hasLocalizedView] = viewName;
 
-    if(acceptLocalizedView && !acceptLocalizedView(viewName, artName))
+    if (acceptLocalizedView && !acceptLocalizedView(viewName, artName))
       return;
 
     let view;
@@ -350,7 +338,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
       if (elem.key || elem.$key || elem.localized)
         textElements.push( elemName );
 
-      // TODO: Already warned about in definer.js
+      // TODO: Already warned about in extend.js
       // if (elem.key && isLocalized)
       //   warning( 'localized-key', path, {}, 'Keyword "localized" is ignored for primary keys' );
     }, artPath);
@@ -360,7 +348,7 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
       return null;
 
     if (!isEntityPreprocessed( art )) {
-      info( null, artPath, { name: artName },
+      messageFunctions.info( null, artPath, { name: artName },
              'Skipped creation of convenience view for $(NAME) because the artifact is missing localization elements' );
       return null;
     }
@@ -369,13 +357,13 @@ function _addLocalizationViews(csn, options, useJoins, acceptLocalizedView = nul
     const textsEntity = csn.definitions[textsName];
 
     if (!textsEntity) {
-      info( null, artPath, { name: artName },
+      messageFunctions.info( null, artPath, { name: artName },
              'Skipped creation of convenience view for $(NAME) because its texts entity could not be found' );
       return null;
     }
 
     if (!isValidTextsEntity( textsEntity )) {
-      info( null, [ 'definitions', textsName ], { name: artName },
+      messageFunctions.info( null, [ 'definitions', textsName ], { name: artName },
              'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid' );
       return null;
     }
@@ -696,18 +684,32 @@ function copyPersistenceAnnotations(target, source) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  */
-function hasExistingLocalizationViews(csn, options) {
+function hasExistingLocalizationViews(csn, options, messageFunctions) {
   if (!csn || !csn.definitions)
     return false;
-  const firstLocalizedView = Object.keys(csn.definitions).find(isInLocalizedNamespace);
-  if (firstLocalizedView) {
-    const { info } = makeMessageFunction(csn, options);
-    info( null, [ 'definitions', firstLocalizedView ], {},
-          'Input CSN already contains expansions for localized data' );
-    return true;
+
+  let hasExistingViews = false;
+  let hasNonViews = false;
+
+  for (const name in csn.definitions) {
+    const art = csn.definitions[name];
+    if (isInLocalizedNamespace(name) || name === 'localized') {
+      if (!art.query && !art.projection) {
+        if (!name.endsWith('.texts')) {
+          hasNonViews = true;
+          messageFunctions.error('reserved-namespace-localized', ['definitions', name], {},
+            'The namespace "localized" is reserved for localization views');
+        }
+      } else if (!hasExistingViews) {
+        hasExistingViews = true;
+        messageFunctions.info( null, [ 'definitions', name ], {},
+          'Input CSN already contains localization views, no further ones will be created' );
+      }
+    }
   }
-  return false;
+  return hasExistingViews || hasNonViews;
 }
 
 /**
@@ -739,9 +741,10 @@ function isEntityPreprocessed(entity) {
 
 /**
  * @param {string} name
+ * @returns {boolean}
  */
 function isInLocalizedNamespace(name) {
-  return name.startsWith('localized.');
+  return name === 'localized' || name.startsWith('localized.');
 }
 
 /**
@@ -749,6 +752,7 @@ function isInLocalizedNamespace(name) {
  *
  * @param {CSN.Model} csn
  * @param {string} artifactName
+ * @returns {boolean}
  */
 function hasLocalizedConvenienceView(csn, artifactName) {
   return !isInLocalizedNamespace(artifactName) && !!csn.definitions[`localized.${ artifactName }`];

package/lib/transform/odata/generateForeignKeyElements.js

@@ -37,7 +37,7 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
     sortedAssociations.forEach(item => {
       const { definitionName, structuralNodeName, elementName, element, parent, path } = item;
 
-      if (csnUtils.isManagedAssociationElement(element) && element.keys) {
+      if (csnUtils.isManagedAssociation(element) && element.keys) {
         if (flatKeys) // tackling the ref value in assoc.keys
           takeoverForeignKeysOfTargetAssociations(element, path, generatedForeignKeyNamesForPath);
         // TODO: move in separate function
@@ -201,13 +201,13 @@ module.exports = function (csn, options, referenceFlattener, csnUtils, error, is
       // Transfer selected type properties from target key element
       // FIXME: There is currently no other way but to treat the annotation '@odata.Type' as a type property.
       for (let prop of ['type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type']) {
-        if (fkArtifact[prop] != undefined) {
+        if (fkArtifact[prop] !== undefined) {
           foreignKeyElement[prop] = fkArtifact[prop];
         }
       }
       // If the association is non-fkArtifact resp. key, so should be the foreign key field
       for (let prop of ['notNull', 'key']) {
-        if (assoc[prop] != undefined) {
+        if (assoc[prop] !== undefined) {
           foreignKeyElement[prop] = assoc[prop];
         }
       }