@sap/cds-compiler 4.0.0 → 4.0.2

package/CHANGELOG.md

@@ -7,6 +7,21 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+
+## Version 4.0.2 - 2023-06-22
+
+### Fixed
+
+- to.sql.migration: When drop-creating views, also drop-create (transitively) dependent views.
+- to.edm(x):
+  + Forward `@odata.singleton { nullable }` annotation to parameter entity.
+  + Annotations assigned to a parameterized entity are propagated to the parameter entity if the annotation is
+    applicable to either an `edm.EntitySet` or `edm.Singleton`. This especially covers all `@Capabilities` and their
+    shortcut forms like `@readonly` and `@insertonly`. The original annotation is not removed from the original entity.
+    Annotations that should be rendered at the parameter `edm.EntityType` can be qualified with `$parameters`.
+    Explicitly qualified annotations are removed from the original entity allowing individual assignments.
+
+
 ## Version 4.0.0 - 2023-06-06
 
 ### Added

package/lib/api/main.js

@@ -384,6 +384,7 @@ function sqlMigration( csn, options, beforeImage ) {
     }, {}),
   };
 
+  const markedSkipByUs = {};
   const cleanup = [];
   // Delete artifacts that are already present in csn
   if (beforeImage?.definitions) {
@@ -404,10 +405,38 @@ function sqlMigration( csn, options, beforeImage ) {
       ) { // don't render again, but need info for primary key extension
         diffArtifact['@cds.persistence.skip'] = true;
         cleanup.push(() => delete diffArtifact['@cds.persistence.skip']);
+        markedSkipByUs[artifactName] = true;
       }
     });
   }
 
+  const sortOrder = sortViews({ sql: {}, csn: afterImage });
+
+  const dependentsDict = {};
+  sortOrder.forEach(({ name, dependents }) => {
+    dependentsDict[name] = dependents;
+  });
+
+  const stack = Object.keys(drops.creates);
+  while (stack.length > 0) {
+    const name = stack.pop();
+    const artifact = diff.definitions[name];
+    if (drops.creates[name] === undefined) {
+      if (artifact['@cds.persistence.skip'] && markedSkipByUs[name]) {
+        // Remove the skip so we render a CREATE VIEW
+        diff.definitions[name]['@cds.persistence.skip'] = false;
+        drops.creates[name] = `DROP VIEW ${ identifierUtils.renderArtifactName(name) };`;
+      }
+    }
+
+    const dependents = dependentsDict[name];
+    if (dependents) { // schedule any dependents for processing that don't have a drop-create yet
+      for (const dependantName in dependents) {
+        if (!drops.creates[dependantName])
+          stack.push(dependantName);
+      }
+    }
+  }
   // Convert the diff to SQL.
   if (!internalOptions.beta)
     internalOptions.beta = {};
@@ -419,7 +448,6 @@ function sqlMigration( csn, options, beforeImage ) {
 
   cleanup.forEach(fn => fn());
   // TODO: Handle `ADD CONSTRAINT` etc!
-  const sortOrder = sortViews({ sql: {}, csn: afterImage });
 
   const dropSqls = [];
   const createAndAlterSqls = [];

package/lib/edm/annotations/genericTranslation.js

@@ -267,6 +267,34 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
   const v = options.v;
 
+  // Copy annotations from origin to parameter entity if it's
+  // qualified with #$parameters or if its applicable to an EntitySet or Singleton
+  forEachDefinition(reqDefs, (object) => {
+    if(object.$isParamEntity && object._origin) {
+      for(const attr in object._origin) {
+        if (attr[0] === '@') {
+          const [ prefix, innerAnnotation ] = attr.split('.@');
+          const ns = whatsMyTermNamespace(prefix);
+          if(ns) {
+            const steps = prefix.replace('@' + ns + '.', '').split('.');
+            const paramAnnoParts = steps[0].split('#$parameters');
+            const dictTerm = getDictTerm(ns + '.' + paramAnnoParts[0], options);
+            if(paramAnnoParts.length > 1 || ['Singleton', 'EntitySet'].some(y => dictTerm?.AppliesTo?.includes(y))) {
+              steps[0] = '@' + ns + '.' + paramAnnoParts.join('');
+              let newAnno = steps.join('.');
+              if(innerAnnotation)
+                newAnno += '.@' + innerAnnotation;
+              edmUtils.assignAnnotation(object, newAnno, object._origin[attr]);
+              // delete original annotation only if it was qualified with $parameters
+              if(paramAnnoParts.length > 1)
+                delete object._origin[attr];
+            }
+          }
+        }
+      }
+    }
+  });
+
   // Crawl over the csn and trigger the annotation translation for all kinds
   //   of annotated things.
   // Note: only works for single service
@@ -771,7 +799,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
         const [ prefix, innerAnnotation ] = a.split('.@');
         const ns = whatsMyTermNamespace(prefix);
         const steps = prefix.replace('@' + ns + '.', '').split('.');
-        steps.splice(0,0, ns);
+        steps.splice(0, 0, ns);
         let i = steps.lastIndexOf('$edmJson');
         if(i > -1) {
           i = steps.findIndex(s => s.includes('@'), i+1);

package/lib/edm/edmPreprocessor.js

@@ -495,7 +495,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
     // create the Parameter Definition
     const parameterCsn = createParameterEntity(entityCsn, entityName, false);
-
+    setProp(parameterCsn, '_origin', entityCsn);
     // create the Type Definition
     // modify the original parameter entity with backlink and new name
     if(csn.definitions[typeEntityName])
@@ -609,6 +609,12 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         [ 'definitions', parameterEntityName, 'elements', parameterToTypeAssocName ] );
     }
 
+    [ '@odata.singleton', '@odata.singleton.nullable' ].forEach(a => {
+      if(entityCsn[a] != null)
+        parameterCsn[a] = entityCsn[a];
+      delete entityCsn[a];
+    });
+
     // initialize containment
     // propagate containment information, if containment is recursive, use parameterCsn.name as $containerNames
     if(entityCsn.$containerNames) {

package/lib/model/sortViews.js

@@ -93,13 +93,12 @@ function _findWithXPointers( definitionsArray, x, _dependents, _dependencies ) {
 module.exports = function sortViews({ sql, csn }) {
   const { cleanup, _dependents, _dependencies } = setDependencies(csn);
   const { layers, leftover } = sortTopologically(csn, _dependents, _dependencies);
-  cleanup.forEach(fn => fn());
   if (leftover.length > 0)
     throw new ModelError('Unable to build a correct dependency graph! Are there cycles?');
 
   const result = [];
   // keep the "artifact name" - needed for to.hdi sorting
-  layers.forEach(layer => layer.forEach(objName => result.push({ name: objName, sql: sql[objName] })));
+  layers.forEach(layer => layer.forEach(objName => result.push({ name: objName, sql: sql[objName], dependents: csn.definitions[objName][_dependents] })));
   // attach sql artifacts which are not considered during the view sorting algorithm
   // --> this is the case for "ALTER TABLE ADD CONSTRAINT" statements,
   //     because their identifiers are not part of the csn.definitions
@@ -107,5 +106,8 @@ module.exports = function sortViews({ sql, csn }) {
     if (!result.some( o => o.name === name )) // not in result but in incoming sql
       result.push({ name, sql: sqlString });
   });
+
+  cleanup.forEach(fn => fn());
+
   return result;
 };

package/lib/transform/forOdataNew.js

@@ -312,79 +312,93 @@ function transform4odataWithCsn(inputModel, options) {
       node['@Core.Computed'] = true;
   }
 
-  // Rename shorthand annotations within artifact or element 'node' according to a builtin
-  // list.
+  // Rename shorthand annotations within artifact or element 'node' according to a builtin list
   function renameShorthandAnnotations(node) {
-    // FIXME: Verify this list - are they all still required? Do we need any more?
     const setMappings = {
       '@label': '@Common.Label',
       '@title': '@Common.Label',
       '@description': '@Core.Description',
     };
     const renameMappings = {
-      '@ValueList.entity': '@Common.ValueList.entity',
-      '@ValueList.type': '@Common.ValueList.type',
-      '@Capabilities.Deletable': '@Capabilities.DeleteRestrictions.Deletable',
-      '@Capabilities.Insertable': '@Capabilities.InsertRestrictions.Insertable',
-      '@Capabilities.Updatable': '@Capabilities.UpdateRestrictions.Updatable',
-      '@Capabilities.Readable': '@Capabilities.ReadRestrictions.Readable',
+      '@ValueList.entity': { val: '@Common.ValueList', op: 'entity' },
+      '@ValueList.type':  { val: '@Common.ValueList', op: 'type' },
+      '@Capabilities.Deletable': { val: '@Capabilities.DeleteRestrictions', op: 'Deletable' },
+      '@Capabilities.Insertable': { val: '@Capabilities.InsertRestrictions', op: 'Insertable' },
+      '@Capabilities.Updatable': { val: '@Capabilities.UpdateRestrictions', op: 'Updatable' },
+      '@Capabilities.Readable': { val: '@Capabilities.ReadRestrictions', op: 'Readable' }
     };
 
     const setShortCuts = Object.keys(setMappings);
     const renameShortCuts = Object.keys(renameMappings);
+
+    // Capabilities shortcuts have precedence over @readonly/@insertonly
     Object.keys(node).forEach( name => {
       if (!name.startsWith('@'))
         return;
       // Rename according to map above
-      const renamePrefix = (name in renameMappings) ? name : renameShortCuts.find(p => name.startsWith(p + '.'));
+      const renamePrefix = (name in renameMappings)
+        ? name 
+        : renameShortCuts.find(p => name.startsWith(p + '.'));
       if(renamePrefix) {
-        renameAnnotation(node, name, name.replace(renamePrefix, renameMappings[renamePrefix]));
-      } else {
+        const mapping = renameMappings[renamePrefix];
+        renameAnnotation(node, name, name.replace(renamePrefix, `${mapping.val}.${mapping.op}`));
+      }
+      else {
         // The two mappings have no overlap, so no need to check for second map if first matched.
         // Rename according to map above
-        const setPrefix = (name in setMappings) ? name : setShortCuts.find(p => name.startsWith(p + '.'));
+        const setPrefix = (name in setMappings)
+          ? name
+          : setShortCuts.find(p => name.startsWith(p + '.') || name.startsWith(p + '#'));
         if(setPrefix) {
           setAnnotation(node, name.replace(setPrefix, setMappings[setPrefix]), node[name]);
         }
       }
+    });
+
+    // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
+    // but '@Core.Computed' for everything else.
 
-      // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
-      // but '@Core.Immutable' for everything else.
-      if (!(node['@readonly'] && node['@insertonly'])) {
-        if (name === '@readonly' && node[name]) {
+    // only if not both readonly/insertonly are true do the mapping
+    if(!(node['@readonly'] && node['@insertonly'])) {
+      if(node['@readonly']) {
+        const setRO = (qualifier) => {
           if (node.kind === 'entity' || node.kind === 'aspect') {
-            setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
-            setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
-            setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
+            setAnnotation(node, `@Capabilities.DeleteRestrictions${ qualifier ? '#' + qualifier : ''}.Deletable`, false);
+            setAnnotation(node, `@Capabilities.InsertRestrictions${ qualifier ? '#' + qualifier : ''}.Insertable`, false);
+            setAnnotation(node, `@Capabilities.UpdateRestrictions${ qualifier ? '#' + qualifier : ''}.Updatable`, false);
           } else {
             setAnnotation(node, '@Core.Computed', true);
           }
-        }
-        // @insertonly is effective on entities/queries only
-        else if (name === '@insertonly' && node[name]) {
-          if (node.kind === 'entity' || node.kind === 'aspect') {
-            setAnnotation(node, '@Capabilities.DeleteRestrictions.Deletable', false);
-            setAnnotation(node, '@Capabilities.ReadRestrictions.Readable', false);
-            setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
-          }
-        }
+        };
+        setRO(undefined);
       }
-      // Only on element level: translate @mandatory
-      if (name === '@mandatory' && node[name] &&
-        node.kind === undefined && node['@Common.FieldControl'] === undefined) {
-        setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
+      // @insertonly is effective on entities/queries only
+      if (node['@insertonly'] && (node.kind === 'entity' || node.kind === 'aspect')) {
+        const setIO = (qualifier) => {
+          setAnnotation(node, `@Capabilities.DeleteRestrictions${ qualifier ? '#' + qualifier : ''}.Deletable`, false);
+          setAnnotation(node, `@Capabilities.ReadRestrictions${ qualifier ? '#' + qualifier : ''}.Readable`, false);
+          setAnnotation(node, `@Capabilities.UpdateRestrictions${ qualifier ? '#' + qualifier : ''}.Updatable`, false);
+        }
+        setIO(undefined);
       }
+    }
 
-      if (name === '@assert.format' && node[name] !== null)
-        setAnnotation(node, '@Validation.Pattern', node['@assert.format']);
+    // @Validation.Pattern is applicable to "Term" => node.kind === annotation
+    if (node['@assert.format'] != null)
+      setAnnotation(node, '@Validation.Pattern', node['@assert.format']);
 
-      if (name === '@assert.range' && node[name] !== null) {
+    // Only on element level
+    if(node.kind == null) {
+      if (node['@mandatory']&& node['@Common.FieldControl'] === undefined) {
+        setAnnotation(node, '@Common.FieldControl', { '#': 'Mandatory' });
+      }
+      if (node['@assert.range'] != null) {
         if (Array.isArray(node['@assert.range']) && node['@assert.range'].length === 2) {
           setAnnotation(node, '@Validation.Minimum', node['@assert.range'][0]);
           setAnnotation(node, '@Validation.Maximum', node['@assert.range'][1]);
         }
       }
-    });
+    }
   }
 
   // Apply default type facets to each type definition and every member

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "4.0.0",
+  "version": "4.0.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",