@sap/cds-compiler 6.0.14 → 6.2.2

package/lib/render/toSql.js

@@ -18,13 +18,13 @@ const {
   getDeltaRenderer,
 } = require('./utils/delta');
 const {
-  renderReferentialConstraint, getIdentifierUtils,
+  renderReferentialConstraint, getIdentifierUtils, isProjectionView,
 } = require('./utils/sql');
 const DuplicateChecker = require('./DuplicateChecker');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
-const { smartFuncId } = require('../sql-identifier');
+const sqlIdentifiers = require('../sql-identifier');
 const { sortCsn } = require('../model/cloneCsn');
 const { manageConstraints, manageConstraint } = require('./manageConstraints');
 const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
@@ -109,8 +109,6 @@ class SqlRenderEnvironment {
  * @returns {object} Dictionary of artifact-type:artifacts, where artifacts is a dictionary of name:content
  */
 function toSqlDdl( csn, options, messageFunctions ) {
-  const withHanaAssociations = options.withHanaAssociations && options.sqlDialect === 'hana';
-
   timetrace.start('SQL rendering');
   const {
     error, warning, info, throwWithAnyError,
@@ -137,10 +135,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
       return renderExpressionRef(x, this.env);
     },
     windowFunction( x) {
-      return renderWindowFunction(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, this.env);
+      return renderWindowFunction(smartFuncId(prepareIdentifier(x.func)), x, this.env);
     },
     func(x) {
-      return renderFunc(smartFuncId(prepareIdentifier(x.func), options.sqlDialect), x, a => renderArgs(a, '=>', this.env, null), { messageFunctions, options, path: this.env.path });
+      return renderFunc(smartFuncId(prepareIdentifier(x.func)), x, a => renderArgs(a, '=>', this.env, null), { messageFunctions, options, path: this.env.path });
     },
     xpr(x) {
       const env = this.env.withSubPath([ 'xpr' ]);
@@ -193,6 +191,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     hdbindex: Object.create(null),
     hdbfulltextindex: Object.create(null),
     hdbview: Object.create(null),
+    hdbprojectionview: Object.create(null),
     hdbconstraint: Object.create(null),
     deletions: Object.create(null),
     constraintDeletions: [],
@@ -212,7 +211,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   const changeElementsDuplicateChecker = new DuplicateChecker();
 
   // Render each artifact on its own
-  forEachDefinition((options && options.testMode) ? sortCsn(csn, options) : csn, (artifact, artifactName) => {
+  forEachDefinition(sortCsnIfTestMode(csn), (artifact, artifactName) => {
     renderDefinitionInto(artifactName, artifact, mainResultObj, new SqlRenderEnvironment());
   });
 
@@ -220,10 +219,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
   for (const artifactName in csn.deletions)
     renderArtifactDeletionInto(artifactName, csn.deletions[artifactName], mainResultObj);
 
-  const supportsSqlExtensions = (options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions'));
-
-  if (csn.changedPrimaryKeys && supportsSqlExtensions) {
-    csn.changedPrimaryKeys = options.testMode ? sortCsn(csn.changedPrimaryKeys) : csn.changedPrimaryKeys;
+  if (csn.changedPrimaryKeys && supportsSqlExtensions()) {
+    csn.changedPrimaryKeys = sortCsnIfTestMode(csn.changedPrimaryKeys);
     csn.changedPrimaryKeys.forEach((artifactName) => {
       const drop = render.dropKey(artifactName);
       addMigration(mainResultObj, artifactName, true, render.concat(...drop));
@@ -233,8 +230,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
   // Render each artifact extension
   // Only SAP HANA SQL is currently supported.
   // Note that extensions may contain new elements referenced in migrations, thus should be compiled first.
-  if (csn.extensions && supportsSqlExtensions) {
-    csn.extensions = options.testMode ? sortCsn(csn.extensions) : csn.extensions;
+  if (csn.extensions && supportsSqlExtensions()) {
+    csn.extensions = sortCsnIfTestMode(csn.extensions);
     for (let i = 0; i < csn.extensions.length; ++i) {
       const extension = csn.extensions[i];
       if (extension.extend) {
@@ -248,8 +245,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
 
   // Render each artifact change
   // Only SAP HANA SQL is currently supported.
-  if (csn.migrations && supportsSqlExtensions) {
-    csn.migrations = options.testMode ? sortCsn(csn.migrations) : csn.migrations;
+  if (csn.migrations && supportsSqlExtensions()) {
+    csn.migrations = sortCsnIfTestMode(csn.migrations);
     for (const migration of csn.migrations) {
       if (migration.migrate) {
         const artifactName = migration.migrate;
@@ -261,8 +258,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
     }
   }
 
-  if (csn.changedPrimaryKeys && supportsSqlExtensions) {
-    csn.changedPrimaryKeys = options.testMode ? sortCsn(csn.changedPrimaryKeys) : csn.changedPrimaryKeys;
+  if (csn.changedPrimaryKeys && supportsSqlExtensions()) {
+    csn.changedPrimaryKeys = sortCsnIfTestMode(csn.changedPrimaryKeys);
     csn.changedPrimaryKeys.forEach((artifactName) => {
       const add = render.addKey(artifactName, csn.definitions[artifactName].elements);
       addMigration(mainResultObj, artifactName, true, render.concat(...add));
@@ -318,26 +315,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
   const sql = Object.create(null);
 
   // Handle hdbKinds separately from alterTable case
-  const {
-    // eslint-disable-next-line no-unused-vars
-    deletions, constraintDeletions, migrations: _, ...hdbKinds
-  } = mainResultObj;
-  for (const hdbKind of Object.keys(hdbKinds)) {
-    for (const name in mainResultObj[hdbKind]) {
-      if (options.src === 'sql') {
-        let sourceString = mainResultObj[hdbKind][name];
-        // Hack: Other than in 'hdbtable' files, in HANA SQL COLUMN is not mandatory but default.
-        if (options.sqlDialect === 'hana' && hdbKind === 'hdbtable' && sourceString.startsWith('COLUMN '))
-          sourceString = sourceString.slice('COLUMN '.length);
-        sql[name] = `CREATE ${ sourceString };`;
-      }
-    }
-    if (options.src === 'sql')
-      delete mainResultObj[hdbKind];
-  }
+  if (options.src === 'sql')
+    adaptHdbKindsForSql();
 
-  // add `ALTER TABLE ADD CONSTRAINT` statements per default for `to.sql` w/ dialect `hana` / `postgres`
-  if (!options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres' /* || options.sqlDialect === 'sqlite' */)) {
+  if (useAlterTableForConstraints()) {
     const constraints = Object.create(null);
     const alterStmts = manageConstraints(csn, options);
 
@@ -351,12 +332,31 @@ function toSqlDdl( csn, options, messageFunctions ) {
   if (options.src === 'sql')
     mainResultObj.sql = sql;
 
-  for (const name in deletions)
-    deletions[name] = `${ deletions[name] }`;
-
   timetrace.stop('SQL rendering');
   return mainResultObj;
 
+  function adaptHdbKindsForSql() {
+    const {
+      hdbtable,
+      // eslint-disable-next-line no-unused-vars
+      deletions, constraintDeletions, migrations: _, ...hdbKinds
+    } = mainResultObj;
+
+    for (const name in hdbtable) {
+      let sourceString = hdbtable[name];
+      // Hack: Other than in 'hdbtable' files, in HANA SQL COLUMN is not mandatory but default.
+      if (sourceString.startsWith('COLUMN '))
+        sourceString = sourceString.slice('COLUMN '.length);
+      sql[name] = `CREATE ${ sourceString };`;
+    }
+
+    for (const hdbKind of Object.keys(hdbKinds)) {
+      for (const name in mainResultObj[hdbKind])
+        sql[name] = `CREATE ${ mainResultObj[hdbKind][name] };`;
+      delete mainResultObj[hdbKind];
+    }
+  }
+
   /**
    * Render a definition into the appropriate dictionary of 'resultObj'.
    *
@@ -373,7 +373,6 @@ function toSqlDdl( csn, options, messageFunctions ) {
         dummySqlServiceEntities[art.$dummyService] ??= Object.create(null);
         dummySqlServiceEntities[art.$dummyService][artifactName] = art;
       }
-
       return;
     }
 
@@ -384,14 +383,12 @@ function toSqlDdl( csn, options, messageFunctions ) {
           sqlServiceEntities[art.$sqlService][artifactName] = art;
         }
 
-        if (art.query || art.projection) {
-          const result = renderView(artifactName, art, env);
-          if (result)
-            resultObj.hdbview[artifactName] = result;
-        }
-        else {
+        if (art.query || art.projection)
+          renderViewInto(artifactName, art, resultObj, env);
+
+        else
           renderEntityInto(artifactName, art, resultObj, env);
-        }
+
         break;
       case 'type':
       case 'context':
@@ -451,8 +448,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderArtifactDeletionInto( artifactName, art, resultObj ) {
     const tableName = renderArtifactName(artifactName);
     deletionsDuplicateChecker.addArtifact(tableName, art.$location, artifactName);
-
-    addDeletion(resultObj, artifactName, `-- [WARNING] this statement is lossy\nDROP TABLE ${ tableName }`);
+    resultObj.deletions[artifactName] = `-- [WARNING] this statement is lossy\nDROP TABLE ${ tableName }`;
   }
 
   // Render an artifact migration into the appropriate dictionary of 'resultObj'.
@@ -534,13 +530,11 @@ function toSqlDdl( csn, options, messageFunctions ) {
         if (migration.removeConstraints[constraintType]) {
           const entries = Object.entries(migration.removeConstraints[constraintType]);
           const optionsWithDrop = { ...options, drop: true };
-          let renderer;
-          if (constraintType === 'referential')
-            renderer = constraint => manageConstraint(constraint, csn, optionsWithDrop, '', quoteSqlId);
-          else
-            renderer = (constraint, constraintName) => renderUniqueConstraintDrop(constraint, renderArtifactName(`${ artifactName }_${ constraintName }`), tableName, quoteSqlId);
+          const renderer = (constraintType === 'referential')
+            ? constraint => manageConstraint(constraint, csn, optionsWithDrop, '', quoteSqlId)
+            : (constraint, constraintName) => renderUniqueConstraintDrop(constraint, renderArtifactName(`${ artifactName }_${ constraintName }`), tableName, quoteSqlId);
           entries.forEach(( [ constraintName, constraint ]) => {
-            addConstraintDeletion(resultObj, constraint.parentTable, renderer(constraint, constraintName));
+            resultObj.constraintDeletions.push(renderer(constraint, constraintName));
           });
         }
       });
@@ -655,9 +649,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     if (primaryKeys !== '')
       result += `,\n${ childEnv.indent }${ primaryKeys }`;
 
-    // for `to.sql` w/ dialect `hana` the constraints will be part of the alter statement
-    const constraintsAsAlter = !options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres');
-    if (!constraintsAsAlter && art.$tableConstraints?.referential) {
+    if (!useAlterTableForConstraints() && art.$tableConstraints?.referential) {
       const renderReferentialConstraintsAsHdbconstraint = options.src === 'hdi';
       const referentialConstraints = {};
       forEach(art.$tableConstraints.referential, ( fileName, referentialConstraint ) => {
@@ -691,7 +683,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       result += renderTechnicalConfiguration(art.technicalConfig, childEnv);
 
 
-    if (withHanaAssociations) {
+    if (supportsHanaAssociations()) {
       const associations = Object.keys(art.elements)
         .map(name => renderAssociationElement(name, art.elements[name], childEnv))
         .filter(s => s !== '')
@@ -706,11 +698,8 @@ function toSqlDdl( csn, options, messageFunctions ) {
     if (options.sqlDialect === 'hana')
       renderIndexesInto(art.technicalConfig?.hana?.indexes, artifactName, resultObj, env);
 
-    if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
-      result += ` COMMENT ${ renderStringForSql(getHanaComment(art), options.sqlDialect) }`;
-
-    if (back)
-      result += back;
+    result += renderComment(art);
+    result += back;
 
     resultObj.hdbtable[artifactName] = result;
   }
@@ -753,24 +742,17 @@ function toSqlDdl( csn, options, messageFunctions ) {
   }
 
   function addMigration( resultObj, artifactName, drop, sqlArray, description ) {
-    if (!(artifactName in resultObj.migrations))
-      resultObj.migrations[artifactName] = [];
+    resultObj.migrations[artifactName] ??= [];
 
-    if (!sqlArray) {
-      if (description)
-        resultObj.migrations[artifactName].push({ description });
-      return;
+    if (sqlArray) {
+      const migrations = sqlArray.map(migrationSql => ({ drop, sql: migrationSql }));
+      resultObj.migrations[artifactName].push(...migrations);
+    }
+    else if (description) {
+      resultObj.migrations[artifactName].push({ description });
     }
-    const migrations = sqlArray.map(migrationSql => ({ drop, sql: migrationSql }));
-    resultObj.migrations[artifactName].push(...migrations);
   }
 
-  function addConstraintDeletion( resultObj, artifactName, deletionSql ) {
-    resultObj.constraintDeletions.push(deletionSql);
-  }
-  function addDeletion( resultObj, artifactName, deletionSql ) {
-    resultObj.deletions[artifactName] = deletionSql;
-  }
 
   /**
    * Retrieve the 'fzindex' (fuzzy index) property (if any) for element 'elemName' from hanaTc (if defined)
@@ -834,8 +816,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     const { back } = getSqlSnippets(options, elm);
     result += back; // Needs to be rendered before the COMMENT
 
-    if (options.sqlDialect === 'hana' && hasHanaComment(elm, options))
-      result += ` COMMENT ${ renderStringForSql(getHanaComment(elm), options.sqlDialect) }`;
+    result += renderComment(elm);
 
     return result;
   }
@@ -892,11 +873,9 @@ function toSqlDdl( csn, options, messageFunctions ) {
    */
   function renderTechnicalConfiguration( tc, env ) {
     let result = '';
-
     if (!tc)
       return result;
 
-
     // FIXME: How to deal with non-HANA technical configurations?
     // This also affects renderIndexes
     tc = tc.hana;
@@ -1213,17 +1192,15 @@ function toSqlDdl( csn, options, messageFunctions ) {
    *
    * @param {string} artifactName Name of the view
    * @param {CSN.Artifact} art CSN view
+   * @param {object} resultObj
    * @param {SqlRenderEnvironment} env Render environment
    * @returns {string} Rendered view
    */
-  function renderView( artifactName, art, env ) {
+  function renderViewInto( artifactName, art, resultObj, env ) {
     const viewName = renderArtifactName(artifactName);
     definitionsDuplicateChecker.addArtifact(art['@cds.persistence.name'], art?.$location, artifactName);
-    let result = `VIEW ${ viewName }`;
-
-    if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
-      result += ` COMMENT ${ renderStringForSql(getHanaComment(art), options.sqlDialect) }`;
-
+    let result = `${ isProjectionView(csn, art, options) ? 'PROJECTION ' : '' }VIEW ${ viewName }`;
+    result += renderComment(art);
     result += renderParameterDefinitions(art.params, env);
     result += ` AS ${ renderQuery(getNormalizedQuery(art).query,
                                   env.withSubPath([ art.projection ? 'projection' : 'query' ]),
@@ -1235,17 +1212,19 @@ function toSqlDdl( csn, options, messageFunctions ) {
       .map(name => renderAssociationElement(name, art.elements[name], childEnv))
       .filter(s => s !== '')
       .join(',\n');
-    if (associations !== '' && withHanaAssociations) {
+    if (associations !== '' && supportsHanaAssociations() && !isProjectionView(csn, art, options)) {
       result += `${ env.indent }\nWITH ASSOCIATIONS (\n${ associations }\n`;
       result += `${ env.indent })`;
     }
 
     // views can only have a @sql.append
     const { back } = getSqlSnippets(options, art);
-    if (back)
-      result += back;
+    result += back;
 
-    return result;
+    if (result && isProjectionView(csn, art, options))
+      resultObj.hdbprojectionview[artifactName] = result;
+    else if (result)
+      resultObj.hdbview[artifactName] = result;
   }
 
   /**
@@ -1517,16 +1496,19 @@ function toSqlDdl( csn, options, messageFunctions ) {
     if (elm.scale !== undefined)
       params.push(elm.scale);
 
-    if (elm.srid !== undefined) {
-      // SAP HANA Geometry types translate into CHAR in plain/sqlite (give them the default length of 2000)
-      if (options.sqlDialect !== 'hana')
-        params.push(2000);
-      else
-        params.push(elm.srid);
-    }
+    if (elm.srid !== undefined)
+      params.push(renderSRID(elm));
+
     return params.length === 0 ? '' : `(${ params.join(', ') })`;
   }
 
+  function renderSRID( element ) {
+    // SAP HANA Geometry types translate into CHAR in plain/sqlite (give them the default length of 2000)
+    if (options.sqlDialect !== 'hana')
+      return 2000;
+    return element.srid;
+  }
+
   function renderExpressionLiteral( x ) {
     // Literal value, possibly with explicit 'literal' property
     switch (x.literal || typeof x.val) {
@@ -1535,22 +1517,19 @@ function toSqlDdl( csn, options, messageFunctions ) {
       case 'null':
         // 17.42, NULL, TRUE
         return String(x.val).toUpperCase();
+
       case 'x':
         // x'f000'
         return `${ x.literal }'${ x.val }'`;
       case 'date':
       case 'time':
       case 'timestamp':
-        if (options.sqlDialect === 'sqlite') {
-          // simple string literal '2017-11-02'
-          return `'${ x.val }'`;
-        }
-        // date'2017-11-02'
-        return `${ x.literal }'${ x.val }'`;
+        return renderTimeLiteral(x);
 
       case 'string':
         // 'foo', with proper escaping
-        return renderStringForSql(x.val, options.sqlDialect);
+        return renderString(x.val);
+
       case 'object':
         if (x.val === null)
           return 'NULL';
@@ -1575,7 +1554,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function renderMagicVariable( ref, env ) {
     const magicReplacement = getVariableReplacement(ref, options);
     if (magicReplacement !== null)
-      return renderStringForSql(magicReplacement, options.sqlDialect);
+      return renderString(magicReplacement);
 
     const name = pathName(ref);
     const result = variableForDialect(options, name, env.isInDefault ? 'default' : null);
@@ -1592,7 +1571,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
               'Variable $(NAME) is not supported. Use option $(OPTION) to specify a value for $(NAME)');
     }
 
-    return renderStringForSql(name, options.sqlDialect);
+    return renderString(name);
   }
 
   /**
@@ -1690,6 +1669,46 @@ function toSqlDdl( csn, options, messageFunctions ) {
   function activateAlterMode( env, changeType ) {
     return env.cloneWith({ alterMode: true, changeType });
   }
+
+
+  function renderComment( art ) {
+    if (options.sqlDialect === 'hana' && hasHanaComment(art, options))
+      return ` COMMENT ${ renderString(getHanaComment(art)) }`;
+    return '';
+  }
+
+  function renderString( str ) {
+    return renderStringForSql(str, options.sqlDialect);
+  }
+
+  function renderTimeLiteral( x ) {
+    if (options.sqlDialect === 'sqlite') {
+      // simple string literal '2017-11-02'
+      return `'${ x.val }'`;
+    }
+    return `${ x.literal }'${ x.val }'`; // date'2017-11-02'
+  }
+
+  function supportsHanaAssociations() {
+    return options.withHanaAssociations && options.sqlDialect === 'hana';
+  }
+
+  function smartFuncId( name ) {
+    return sqlIdentifiers.smartFuncId(name, options.sqlDialect);
+  }
+
+  function supportsSqlExtensions() {
+    return options.sqlDialect === 'hana' || isBetaEnabled(options, 'sqlExtensions');
+  }
+
+  function sortCsnIfTestMode( obj ) {
+    return options?.testMode ? sortCsn(obj, options) : obj;
+  }
+
+  function useAlterTableForConstraints() {
+    // for `to.sql` w/ dialect `hana` the constraints will be part of the alter statement
+    return !options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres');
+  }
 }
 
 /**

package/lib/render/utils/sql.js

@@ -5,6 +5,7 @@
 const { getResultingName } = require('../../model/csnUtils');
 const { smartId, delimitedId } = require('../../sql-identifier');
 const { ModelError } = require('../../base/error');
+const { isBetaEnabled, setProp } = require('../../base/model');
 
 /**
  * Render a given referential constraint as part of a SQL CREATE TABLE statement, or as .hdbconstraint artefact.
@@ -142,8 +143,74 @@ function getIdentifierUtils( csn, options ) {
   }
 }
 
+const allowedHdbProjectionViewProperties = {
+  from: true,
+  mixin: true,
+  columns: true,
+};
+
+/**
+ * Determines if the given artifact is a projection view. Caches the information via
+ * non-enumerable property `$isProjectionView` on the artifact for non-trivial cases.
+ *
+ * Requires a for.hana processed model including A2J.
+ *
+ * @param {CSN.Model} csn - The Core Schema Notation (CSN) model.
+ * @param {CSN.Artifact} artifact - The artifact to check for being a projection view.
+ * @param {Model.Options} options - Compilation options, including feature flags and SQL dialect.
+ * @returns {boolean} `true` if the artifact is a projection view, otherwise `false`.
+ */
+function isProjectionView( csn, artifact, options ) {
+  if (!isBetaEnabled(options, 'projectionViews') || !artifact.projection || options.sqlDialect !== 'hana' || artifact.params || !artifact.$dataProductService)
+    return false;
+
+  if (artifact.$isProjectionView !== undefined)
+    return artifact.$isProjectionView;
+
+  setProp(artifact, '$isProjectionView', _artifactIsProjectionView(csn, artifact));
+
+  return artifact.$isProjectionView;
+}
+
+function _artifactIsProjectionView( csn, artifact ) {
+  for (const prop of Object.keys(artifact.projection)) {
+    if (!prop.startsWith('@') && !allowedHdbProjectionViewProperties[prop])
+      return false;
+  }
+
+  const source = csn.definitions[artifact.projection.from.ref[0]];
+  if (!source)
+    return false;
+
+  // Source must be a table or a projection view. Only support table for now
+  if (source.kind !== 'entity' || source.query || source.projection)
+    return false;
+
+  const referencedElements = Object.create(null);
+
+  for (const column of artifact.projection.columns) {
+    if (!column.ref)
+      return false;
+
+    if (referencedElements[column.ref.at(-1)])
+      return false; // we have an element projected more than once, seems to not be supported
+
+    referencedElements[column.ref.at(-1)] = true;
+  }
+
+  // Full primary key needs to be projected according to HANA SQL spec
+  for (const elementName in source.elements) {
+    const element = source.elements[elementName];
+    if (element.key && !referencedElements[elementName])
+      return false;
+  }
+
+  return true;
+}
+
 
 module.exports = {
   renderReferentialConstraint,
   getIdentifierUtils,
+  isProjectionView,
 };

package/lib/transform/addTenantFields.js

@@ -85,7 +85,7 @@ function addTenantFields( csn, options, messageFunctions ) {
     else if (!independent && independent != null) {
       error( 'tenant-invalid-anno-value', msgLocations( csnPath ),
              { anno: annoTenantIndep, value: independent },
-             // eslint-disable-next-line @stylistic/js/max-len
+             // eslint-disable-next-line @stylistic/max-len
              'Can\'t add $(ANNO) with value $(VALUE) to a non-entity, which is always tenant-independent' );
     }
     else if (art.includes) {
@@ -129,9 +129,9 @@ function addTenantFields( csn, options, messageFunctions ) {
       .filter( name => isTenantDepEntity( csn.definitions[name] ) );
     if (names.length) {
       error( 'tenant-invalid-include', msgLocations( csnPath ), { names }, {
-        // eslint-disable-next-line @stylistic/js/max-len
+        // eslint-disable-next-line @stylistic/max-len
         std: 'Can\'t include the tenant-dependent entities $(NAMES) into a tenant-independent definition',
-        // eslint-disable-next-line @stylistic/js/max-len
+        // eslint-disable-next-line @stylistic/max-len
         one: 'Can\'t include the tenant-dependent entity $(NAMES) into a tenant-independent definition',
       } );
     }
@@ -221,7 +221,7 @@ function addTenantFields( csn, options, messageFunctions ) {
     if (art[annoTenantIndep]) {
       error( 'tenant-expecting-tenant-source', msgLocations( csnPath ), { art: query },
              // TODO: better the final entity name of assoc navigation in FROM
-             // eslint-disable-next-line @stylistic/js/max-len
+             // eslint-disable-next-line @stylistic/max-len
              'Expecting the query source $(ART) to be tenant-dependent for a tenant-dependent query entity' );
     }
     return true;

package/lib/transform/db/killAnnotations.js

@@ -26,6 +26,7 @@ const requiredAnnos = {
   '@Core.Computed': true,
   [sqlServiceAnnotation]: true,
   '@cds.external': true, // for external ABAP SQL services and data products for now
+  '@DataIntegration.dataproduct.type': true, // for data product production
 };
 
 /**

package/lib/transform/db/processSqlServices.js

@@ -16,12 +16,15 @@ const sqlServiceAnnotation = '@protocol';
 function processSqlServices(csn, options) {
   setProp(csn, '$sqlServiceEntities', Object.create(null));
   setProp(csn, '$dummyServiceEntities', Object.create(null));
+  setProp(csn, '$dataProductEntities', Object.create(null));
   return function findAndMarkSqlServiceArtifacts(artifact, artifactName) {
-    const { sqlServiceName, dummyServiceName } = isEntityInSqlService(artifact, artifactName, csn, options);
+    const { sqlServiceName, dummyServiceName, dataProductServiceName } = isEntityInSqlService(artifact, artifactName, csn, options);
     if (sqlServiceName?.length > 0)
       setProp(artifact, '$sqlService', sqlServiceName);
     if (dummyServiceName?.length > 0)
       setProp(artifact, '$dummyService', dummyServiceName);
+    if (dataProductServiceName?.length > 0)
+      setProp(artifact, '$dataProductService', dataProductServiceName);
   };
 }
 
@@ -55,7 +58,7 @@ function isDummyService(artifact, options) {
  * @returns {object} An object containing the names of the SQL service and external ABAP SQL service, if found.
  */
 function isEntityInSqlService(artifact, artifactName, csn, options) {
-  const result = { sqlServiceName: undefined, dummyServiceName: undefined };
+  const result = { sqlServiceName: undefined, dummyServiceName: undefined, dataProductServiceName: undefined };
   if (artifact.kind !== 'entity' || !artifactName.includes('.') || hasPersistenceSkipAnnotation(artifact))
     return result;
 
@@ -72,6 +75,9 @@ function isEntityInSqlService(artifact, artifactName, csn, options) {
     if (isDummyService(definition, options))
       result.dummyServiceName = possibleServiceName;
 
+    if (isDataProductService(definition, options))
+      result.dataProductServiceName = possibleServiceName;
+
     // We don't allow nested services/contexts - if we find one, we don't need to keep searching
     if (definition.kind === 'service' || definition.kind === 'context')
       return result;
@@ -108,10 +114,22 @@ function createServiceDummy(artifact, artifactName, csn, { error }) {
     csn.definitions[`dummy.${ artifactName }`] = dummy;
 }
 
+/**
+ * Determines if the given artifact is a data product service.
+ *
+ * @param {object} artifact - The artifact to evaluate.
+ * @param {object} options - The options object containing feature flags.
+ * @returns {boolean} - Returns `true` if the artifact is a data product service, otherwise `false`.
+ */
+function isDataProductService(artifact, options) {
+  return isBetaEnabled(options, 'projectionViews') && artifact.kind === 'service' && artifact['@DataIntegration.dataproduct.type'] === 'primary';
+}
+
 module.exports = {
   processSqlServices,
   isSqlService,
   isDummyService,
+  isDataProductService,
   sqlServiceAnnotation,
   createServiceDummy,
 };

package/lib/transform/draft/db.js

@@ -232,7 +232,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     draftAdministrativeData.DraftAdministrativeData.notNull = true;
     addElement(draftAdministrativeData, draftsArtifact, artifactName);
 
-    if (isBetaEnabled(options, 'draftMessages')) {
+    if (isBetaEnabled(options, 'draftMessages') || options.draftMessages) {
       const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
       addElement(draftMessages, draftsArtifact, artifactName);
     }