@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/render/utils/common.js

@@ -279,6 +279,18 @@ const cdsToSqlTypes = {
     'cds.hana.BINARY': 'BINARY',
     'cds.hana.SMALLDECIMAL': 'DECIMAL',
   },
+  postgres: {
+    // TODO: Type mapping for binary types is not correct, yet.
+    // We can't use text types for binary on PostgreSQL due to NUL!
+    'cds.String': 'VARCHAR',
+    'cds.LargeString': 'text',
+    'cds.hana.CLOB': 'text',
+    'cds.LargeBinary': 'bytea',
+    'cds.Binary': 'bytea',
+    'cds.hana.BINARY': 'bytea',
+    'cds.Double': 'double precision',
+    'cds.hana.TINYINT': 'INTEGER',
+  },
 };
 
 /**
@@ -346,11 +358,10 @@ function hasHanaComment(obj, options) {
  * Return the comment of the given artifact or element.
  * Uses the first block (everything up to the first empty line (double \n)).
  * Remove leading/trailing whitespace.
- * Does not escape any characters.
+ * Does not escape any characters, use e.g. `getEscapedHanaComment()` for HDBCDS.
  *
  * @param {CSN.Artifact|CSN.Element} obj
  * @returns {string}
- * @todo Warning/info to user?
  */
 function getHanaComment(obj) {
   return obj.doc.split('\n\n')[0].trim();
@@ -375,7 +386,7 @@ function getSqlSnippets(options, obj) {
  * A function used to render a certain part of an expression object
  *
  * @callback renderPart
- * @param {object||array} expression
+ * @param {object|array} expression
  * @param {CdlRenderEnvironment} env
  * @this {{inline: Boolean, nestedExpr: Boolean}}
  * @returns {string}
@@ -397,6 +408,8 @@ function getSqlSnippets(options, obj) {
  * @property {renderPart} xpr
  * @property {renderPart} SELECT
  * @property {renderPart} SET
+ * @property {boolean} [inline]
+ * @property {boolean} [nestedExpr]
  */
 
 /**

package/lib/render/utils/sql.js

@@ -40,18 +40,18 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
   }
 
   const renderAsHdbconstraint = options.transformation === 'hdbcds' ||
-                                (options.toSql && options.toSql.src === 'hdi') ||
+                                options.src === 'hdi' ||
                                 (options.manageConstraints && options.manageConstraints.src === 'hdi');
 
-  const { names } = options.forHana;
-  const forSqlite = options.toSql && options.toSql.dialect === 'sqlite';
+  const { sqlMapping } = options;
+  const forSqlite = options.sqlDialect === 'sqlite';
   let result = '';
   result += `${indent}CONSTRAINT ${quoteId(constraint.identifier)}\n`;
   if (renderAsHdbconstraint)
-    result += `${indent}ON ${quoteId(getResultingName(csn, names, constraint.dependentTable))}\n`;
+    result += `${indent}ON ${quoteId(getResultingName(csn, sqlMapping, constraint.dependentTable))}\n`;
   if (!alterConstraint) {
     result += `${indent}FOREIGN KEY(${constraint.foreignKey.map(quoteId).join(', ')})\n`;
-    result += `${indent}REFERENCES ${quoteId(getResultingName(csn, names, constraint.parentTable))}(${constraint.parentKey.map(quoteId).join(', ')})\n`;
+    result += `${indent}REFERENCES ${quoteId(getResultingName(csn, sqlMapping, constraint.parentTable))}(${constraint.parentKey.map(quoteId).join(', ')})\n`;
     const onDeleteRemark = constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : '';
 
     // omit 'RESTRICT' action for ON UPDATE / ON DELETE, because it interferes with deferred constraint check
@@ -65,12 +65,13 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     }
   }
   // constraint enforcement / validation must be switched off using sqlite pragma statement
-  if (options.toSql && options.toSql.dialect !== 'sqlite') {
+  // Does not include HDBCDS.
+  if (options.toSql && !forSqlite) {
     result += `${indent}${!constraint.validated ? 'NOT ' : ''}VALIDATED\n`;
     result += `${indent}${!constraint.enforced ? 'NOT ' : ''}ENFORCED\n`;
   }
   // for sqlite, the DEFERRABLE keyword is required
-  result += `${indent}${options.toSql && options.toSql.dialect === 'sqlite' ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
+  result += `${indent}${forSqlite ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
   return result;
 }
 
@@ -85,9 +86,9 @@ function getIdentifierUtils(options) {
   /**
    * Return 'name' with appropriate "-quotes.
    * Additionally perform the following conversions on 'name'
-   * If 'options.toSql.names' is 'plain'
+   * If 'options.sqlMapping' is 'plain'
    *   - replace '.' or '::' by '_'
-   * else if 'options.toSql.names' is 'quoted'
+   * else if 'options.sqlMapping' is 'quoted'
    *   - replace '::' by '.'
    * Complain about names that collide with known SQL keywords or functions
    *
@@ -97,13 +98,13 @@ function getIdentifierUtils(options) {
   function quoteSqlId(name) {
     name = prepareIdentifier(name);
 
-    switch (options.toSql.names) {
+    switch (options.sqlMapping) {
       case 'plain':
-        return smartId(name, options.toSql.dialect);
+        return smartId(name, options.sqlDialect);
       case 'quoted':
-        return delimitedId(name, options.toSql.dialect);
+        return delimitedId(name, options.sqlDialect);
       case 'hdbcds':
-        return delimitedId(name, options.toSql.dialect);
+        return delimitedId(name, options.sqlDialect);
       default:
         return undefined;
     }
@@ -111,9 +112,9 @@ function getIdentifierUtils(options) {
 
   /**
      * Prepare an identifier:
-     * If 'options.toSql.names' is 'plain'
+     * If 'options.sqlMapping' is 'plain'
      *   - replace '.' or '::' by '_'
-     * else if 'options.toSql.names' is 'quoted'
+     * else if 'options.sqlMapping' is 'quoted'
      *  - replace '::' by '.'
      *
      * @param {string} name Identifier to prepare
@@ -121,11 +122,11 @@ function getIdentifierUtils(options) {
      */
   function prepareIdentifier(name) {
     // Sanity check
-    if (options.toSql.dialect === 'sqlite' && options.toSql.names !== 'plain')
-      throw new ModelError(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
+    if (options.sqlDialect === 'sqlite' && options.sqlMapping !== 'plain')
+      throw new ModelError(`Not expecting ${options.sqlMapping} names for 'sqlite' dialect`);
 
 
-    switch (options.toSql.names) {
+    switch (options.sqlMapping) {
       case 'plain':
         return name.replace(/(\.|::)/g, '_');
       case 'quoted':
@@ -133,7 +134,7 @@ function getIdentifierUtils(options) {
       case 'hdbcds':
         return name;
       default:
-        throw new ModelError(`No matching rendering found for naming mode ${options.toSql.names}`);
+        throw new ModelError(`No matching rendering found for naming mode ${options.sqlMapping}`);
     }
   }
 }

package/lib/sql-identifier.js

@@ -45,6 +45,12 @@ const sqlDialects = {
     effectiveName: name => name,
     asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
   },
+  postgres: {
+    regularRegex: /^[A-Za-z_][A-Za-z_$0-9]*$/,
+    reservedWords: keywords.postgres,
+    effectiveName: name => name.toLowerCase(),
+    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+  },
   hana: {
     regularRegex: /^[A-Za-z_][A-Za-z_$#0-9]*$/,
     reservedWords: keywords.hana,

package/lib/transform/db/.eslintrc.json

@@ -17,15 +17,16 @@
     "sonarjs/prefer-single-boolean-return": "off",
     // Very whiny and nitpicky
     "sonarjs/cognitive-complexity": "off",
+    "sonarjs/no-duplicate-string": "off",
     // Does not recognize TS types
     "jsdoc/no-undefined-types": "off"
   },
   "parserOptions": {
-    "ecmaVersion": 2018,
+    "ecmaVersion": 2020,
     "sourceType": "script"
   },
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": true
   },
   "settings": {

package/lib/transform/db/associations.js

@@ -107,12 +107,12 @@ function attachOnConditions(csn, pathDelimiter) {
  * @param {string} pathDelimiter
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
  */
-function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
+function getFKAccessFinalizer(csn, pathDelimiter) {
   const {
     inspectRef,
   } = getUtils(csn);
 
-  return handleManagedAssocStepsInOnCondition;
+  return handleManagedAssocSteps;
 
   /**
    * Loop over all elements and for all unmanaged associations translate
@@ -123,45 +123,53 @@ function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
    * @param {CSN.Artifact} artifact Artifact to check
    * @param {string} artifactName Name of the artifact
    */
-  function handleManagedAssocStepsInOnCondition(artifact, artifactName) {
-    for (const elemName in artifact.elements) {
-      const elem = artifact.elements[elemName];
-      // The association is an unmanaged on
-      if (!elem.keys && elem.target && elem.on) {
-        applyTransformationsOnNonDictionary(elem, 'on', {
-          ref: (refOwner, prop, ref, path) => {
-            // [<assoc base>.]<managed assoc>.<field>
-            if (ref.length > 1) {
-              const { links } = inspectRef(path);
-              if (links) {
-                // eslint-disable-next-line for-direction
-                for (let i = links.length - 1; i >= 0; i--) {
-                  const link = links[i];
-                  // We found the latest managed assoc path step
-                  if (link.art && link.art.target && link.art.keys &&
+  function handleManagedAssocSteps(artifact, artifactName) {
+    const transformer = {
+      ref: (refOwner, prop, ref, path) => {
+        // [<assoc base>.]<managed assoc>.<field>
+        if (ref.length > 1) {
+          const { links } = inspectRef(path);
+          if (links) {
+            // eslint-disable-next-line for-direction
+            for (let i = links.length - 1; i >= 0; i--) {
+              const link = links[i];
+              // We found the latest managed assoc path step
+              if (link.art && link.art.target && link.art.keys &&
                     // Doesn't work when ref-target (filter condition) or similar is used
                     !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
-                    // We join the managed assoc with everything following it
-                    const sourceElementName = ref.slice(i).join(pathDelimiter);
-                    const source = findSource(links, i - 1) || artifact;
-                    // allow specifying managed assoc on the source side
-                    const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] === sourceElementName);
-                    if (fks && fks.length >= 1) {
-                      const fk = fks[0];
-                      const managedAssocStepName = refOwner.ref[i];
-                      const fkName = `${managedAssocStepName}${pathDelimiter}${fk.as}`;
-                      if (source && source.elements[fkName])
-                        refOwner.ref = [ ...ref.slice(0, i), fkName ];
-                    }
-                  }
+                // We join the managed assoc with everything following it
+                const sourceElementName = ref.slice(i).join(pathDelimiter);
+                const source = findSource(links, i - 1) || artifact;
+                // allow specifying managed assoc on the source side
+                const fks = link.art.keys.filter(fk => ref[i] + pathDelimiter + fk.ref[0] === sourceElementName);
+                if (fks && fks.length >= 1) {
+                  const fk = fks[0];
+                  const managedAssocStepName = refOwner.ref[i];
+                  const fkName = `${managedAssocStepName}${pathDelimiter}${fk.as}`;
+                  if (source && source.elements[fkName])
+                    refOwner.ref = [ ...ref.slice(0, i), fkName ];
                 }
               }
             }
-          },
-        }, {}, [ 'definitions', artifactName, 'elements', elemName ]);
-      }
+          }
+        }
+      },
+    };
+    for (const elemName in artifact.elements) {
+      const elem = artifact.elements[elemName];
+      // The association is an unmanaged one
+      if (!elem.keys && elem.target && elem.on)
+        applyTransformationsOnNonDictionary(elem, 'on', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+    }
+
+    if (artifact.query || artifact.projection) {
+      applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', {
+        orderBy: (parent, prop, thing, path) => applyTransformationsOnNonDictionary(parent, prop, transformer, {}, path),
+        groupBy: (parent, prop, thing, path) => applyTransformationsOnNonDictionary(parent, prop, transformer, {}, path),
+      }, {}, [ 'definitions', artifactName ]);
     }
 
+
     /**
      * Find out where the managed association is
      *
@@ -183,5 +191,5 @@ function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
 }
 module.exports = {
   attachOnConditions,
-  getManagedAssocStepsInOnConditionFinalizer,
+  getFKAccessFinalizer,
 };

package/lib/transform/db/cdsPersistence.js

@@ -78,29 +78,18 @@ function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
    * @param {string} memberName
    * @param {string} prop
    * @param {CSN.Path} path
-   * @todo Why do we check for @cds.persistence.exists here if the parent-function only calls this for skip/abstract?
    */
   function ignore(member, memberName, prop, path) {
-    if (options.sqlDialect === 'hana' && !member._ignore && member.target && isAssocOrComposition(member.type) && isUnreachableAssociationTarget(csn.definitions[member.target])) {
-      const targetAnnotation = hasAnnotationValue(csn.definitions[member.target], exists) ? exists : '@cds.persistence.skip';
+    if (options.sqlDialect === 'hana' &&
+       !member._ignore && member.target &&
+       isAssocOrComposition(member.type) &&
+       !isPersistedOnDatabase(csn.definitions[member.target])) {
       info(null, path,
-           { target: member.target, anno: targetAnnotation },
+           { target: member.target, anno: '@cds.persistence.skip' },
            'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
       member._ignore = true;
     }
   }
-
-  /**
-   * Check whether the given artifact is an unreachable association target because it will not "realy" hit the database:
-   * - @cds.persistence.skip/exists
-   * - abstract
-   *
-   * @param {CSN.Artifact} art
-   * @returns {boolean}
-   */
-  function isUnreachableAssociationTarget(art) {
-    return !isPersistedOnDatabase(art) || hasAnnotationValue(art, exists);
-  }
 }
 
 /**

package/lib/transform/db/constraints.js

@@ -517,7 +517,7 @@ function createReferentialConstraints(csn, options) {
         onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
       referentialConstraints[`${getResultingName(csn, 'quoted', artifactName)}_${$foreignKeyConstraint.sourceAssociation}`] = {
         // constraint identifier start with `c__` to avoid name clashes
-        identifier: `c__${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
+        identifier: `c__${getResultingName(csn, options.sqlMapping, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
         foreignKey: dependentKey,
         parentKey,
         dependentTable: artifactName,

package/lib/transform/db/expansion.js

@@ -24,10 +24,11 @@ const { forEach } = require('../../utils/objectUtils');
  * @param {object} iterateOptions
  */
 function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {}) {
+  const csnUtils = getUtils(csn);
   const {
-    isStructured, get$combined, getFinalBaseType, getServiceName,
-  } = getUtils(csn);
-  let { effectiveType, inspectRef } = csnRefs(csn);
+    isStructured, get$combined, getFinalBaseTypeWithProps, getServiceName,
+  } = csnUtils;
+  let { effectiveType, inspectRef } = csnUtils;
 
   if (isBetaEnabled(options, 'nestedProjections'))
     rewriteExpandInline();
@@ -239,13 +240,13 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      */
     function nextBase(parent, base) {
       if (parent.ref) {
-        const finalBaseType = getFinalBaseType(parent._art.type);
+        const finalBaseType = getFinalBaseTypeWithProps(parent._art.type);
         const art = parent._art;
 
-        if (finalBaseType === 'cds.Association' || finalBaseType === 'cds.Composition')
+        if (finalBaseType && (finalBaseType.type === 'cds.Association' || finalBaseType.type === 'cds.Composition'))
           return csn.definitions[art.target].elements;
 
-        return art.elements || finalBaseType.elements;
+        return art.elements || finalBaseType?.elements;
       }
 
       return base;

package/lib/transform/db/flattening.js

@@ -67,8 +67,8 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
         stack.push(...Object.values(current.elements));
     }
   }
-  const { toFinalBaseType } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  const { getServiceName, getFinalBaseType } = getUtils(csn);
+  const { toFinalBaseType, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { getServiceName, getFinalBaseTypeWithProps } = csnUtils;
 
   // We don't want to iterate over actions
   if (iterateOptions.skipDict && !iterateOptions.skipDict.actions)
@@ -89,7 +89,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
       if (options.toOdata && parent.kind && parent.kind in ignoreOdataKinds)
         return;
       if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
-        toFinalBaseType(parent, resolved);
+        toFinalBaseType(parent, resolved, true);
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
         if (parent.elements) {
@@ -98,7 +98,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
             const elements = stack.pop();
             for (const e of Object.values(elements)) {
               if (e.type && !isBuiltinType(e.type))
-                toFinalBaseType(e, resolved);
+                toFinalBaseType(e, resolved, true);
 
               if (e.elements)
                 stack.push(e.elements);
@@ -152,11 +152,11 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
    * @returns {boolean}
    */
   function isODataV4BuiltinFromService(typeName, path) {
-    if (!options.toOdata || (options.toOdata && options.toOdata.version === 'v2') || typeof typeName !== 'string')
+    if (!options.toOdata || (options.odataVersion === 'v2') || typeof typeName !== 'string')
       return false;
 
     const typeServiceName = getServiceName(typeName);
-    const finalBaseType = getFinalBaseType(typeName);
+    const finalBaseType = getFinalBaseTypeWithProps(typeName)?.type;
     // we need the service of the current definition
     const currDefServiceName = getServiceName(path[1]);
 
@@ -266,9 +266,8 @@ function flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter, iter
  * @param {object} iterateOptions
  */
 function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}) {
-  const { isAssocOrComposition } = getUtils(csn);
-  const { flattenStructuredElement } = transformUtils.getTransformers(csn, options, pathDelimiter);
-  const { effectiveType } = csnRefs(csn);
+  const { flattenStructuredElement, csnUtils } = transformUtils.getTransformers(csn, options, pathDelimiter);
+  const { isAssocOrComposition, effectiveType } = csnUtils;
   const transformers = {
     elements: flatten,
   };
@@ -299,11 +298,13 @@ function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}
         const flatElems = flattenStructuredElement(element, elementName, [], path.concat([ 'elements', elementName ]));
 
         for (const flatElemName in flatElems) {
-          if (parent[prop][flatElemName])
+          if (parent[prop][flatElemName]) {
             // TODO: combine message ID with generated FK duplicate
-            // do the duplicate check in the consruct callback, requires to mark generated flat elements,
+            // do the duplicate check in the construct callback, requires to mark generated flat elements,
             // check: Error location should be the existing element like @odata.foreignKey4
-            error(null, path.concat([ 'elements', elementName ]), `"${path[1]}.${elementName}": Flattened struct element name conflicts with existing element: "${flatElemName}"`);
+            error('name-duplicate-element', path.concat([ 'elements', elementName ]),
+                  { '#': 'flatten-element-exist', name: flatElemName });
+          }
 
           const flatElement = flatElems[flatElemName];
 
@@ -609,8 +610,7 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
           ((options.toOdata && isDeepEqual(element, parent[prop][fk[0]], true)) ||
             !options.toOdata)) {
             // error location is the colliding element
-            error(null, eltPath, { name: fk[0], art: elementName },
-                  'Generated foreign key element $(NAME) for association $(ART) conflicts with existing element');
+            error('name-duplicate-element', eltPath, { '#': 'flatten-fkey-exists', name: fk[0], art: elementName });
           }
           // attach a proper $path
           setProp(element, '$path', eltPath);
@@ -619,10 +619,8 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
 
         // check for duplicate foreign keys
         Object.entries(refCount).forEach(([ name, occ ]) => {
-          if (occ > 1) {
-            error(null, eltPath, { name },
-                  'Duplicate definition of foreign key element $(NAME)');
-          }
+          if (occ > 1)
+            error('name-duplicate-element', eltPath, { '#': 'flatten-fkey-gen', name, art: elementName });
         });
         if (element.keys) {
           element.keys.forEach((key, i) => {

package/lib/transform/db/transformExists.js

@@ -349,7 +349,7 @@ function handleExists(csn, options, error) {
     const newExpr = [];
     const query = walkCsnPath(csn, queryPath);
     const expr = walkCsnPath(csn, exprPath);
-    const queryBase = query.SELECT.from.ref ? (query.SELECT.from.as || query.SELECT.from.ref[0]) : null;
+    const queryBase = query.SELECT.from.ref ? (query.SELECT.from.as || query.SELECT.from.ref) : null;
     const sources = getQuerySources(query.SELECT);
 
     for (let i = 0; i < expr.length; i++) {
@@ -457,7 +457,7 @@ function handleExists(csn, options, error) {
    *
    * A valid $self-backlink is handled in translateDollarSelfToWhere.
    *
-   * For an ordinary unmanaged association, we do the the following for each part of the on-condition:
+   * For an ordinary unmanaged association, we do the following for each part of the on-condition:
    * - target side: We prefix the real target and cut off the assoc-name from the ref
    * - source side w/ leading $self: We remove the $self and add the source side entity/query source
    * - source side w/o leading $self: We simply add the source side entity/query source in front of the ref
@@ -730,15 +730,17 @@ function handleExists(csn, options, error) {
   /**
    * Get the name of the source-side query source
    *
-   * @param {string|null} queryBase
+   * @param {string | Array | null} queryBase
    * @param {boolean} isPrefixedWithTableAlias
    * @param {CSN.Column} current
    * @param {CSN.Path} path
    * @returns {string}
    */
   function getBase(queryBase, isPrefixedWithTableAlias, current, path) {
-    if (queryBase)
-      return getRealName(csn, queryBase);
+    if (typeof queryBase === 'string') // alias
+      return queryBase;
+    else if (queryBase) // ref
+      return queryBase.length > 1 ? queryBase[queryBase.length - 1] : getRealName(csn, queryBase[0]);
     else if (isPrefixedWithTableAlias)
       return current.ref[0];
     return getParent(current, path);

package/lib/transform/db/views.js

@@ -3,7 +3,7 @@
 const {
   getUtils, cloneCsnNonDict, applyTransformationsOnNonDictionary,
 } = require('../../model/csnUtils');
-const { implicitAs, csnRefs } = require('../../model/csnRefs');
+const { implicitAs } = require('../../model/csnRefs');
 const { isBetaEnabled } = require('../../base/model');
 const { ModelError } = require('../../base/error');
 
@@ -69,9 +69,9 @@ function usesMixinAssociation(query, association, associationName) {
 function getViewTransformer(csn, options, messageFunctions, transformCommon) {
   const {
     get$combined, isAssocOrComposition,
+    inspectRef, queryOrMain, // csnRefs
   } = getUtils(csn);
-  const { inspectRef, queryOrMain } = csnRefs(csn);
-  const pathDelimiter = (options.forHana.names === 'hdbcds') ? '.' : '_';
+  const pathDelimiter = options.forHana && (options.sqlMapping === 'hdbcds') ? '.' : '_';
   const { error, info } = messageFunctions;
   const doA2J = !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds');
 

package/lib/transform/draft/.eslintrc.json

@@ -23,11 +23,11 @@
     "sonarjs/no-duplicate-string": "off"
   },
   "parserOptions": {
-    "ecmaVersion": 2018,
+    "ecmaVersion": 2020,
     "sourceType": "script"
   },
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": true
   },
   "settings": {

package/lib/transform/draft/db.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  hasAnnotationValue, getUtils, getServiceNames, forEachDefinition,
+  hasAnnotationValue, getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively,
 } = require('../../model/csnUtils');
 const { setProp, isDeprecatedEnabled } = require('../../base/model');
@@ -19,15 +19,15 @@ const booleanBuiltin = 'cds.Boolean';
  * @param {object} messageFunctions
  */
 function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
-  const draftSuffix = isDeprecatedEnabled(options, 'generatedEntityNameWithUnderscore') ? '_drafts' : '.drafts';
+  const draftSuffix = '.drafts';
   // All services of the model - needed for drafts
   const allServices = getServiceNames(csn);
   const draftRoots = new WeakMap();
   const {
     createForeignKeyElement, createAndAddDraftAdminDataProjection, createScalarElement, createAssociationElement,
-    addElement, copyAndAddElement, createAssociationPathComparison,
+    addElement, copyAndAddElement, createAssociationPathComparison, csnUtils,
   } = getTransformers(csn, options, pathDelimiter);
-  const { getCsnDef, isComposition } = getUtils(csn);
+  const { getCsnDef, isComposition } = csnUtils;
   const { error, warning } = messageFunctions;
 
   forEachDefinition(csn, generateDraft);
@@ -155,7 +155,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
             'Generated entity $(NAME) conflicts with existing artifact');
     }
 
-    const persistenceName = getResultingName(csn, options.forHana.names, draftsArtifactName);
+    const persistenceName = getResultingName(csn, options.sqlMapping, draftsArtifactName);
     // Duplicate the artifact as a draft shadow entity
     if (csn.definitions[persistenceName]) {
       const definingDraftRoot = draftRoots.get(csn.definitions[persistenceName]);
@@ -187,7 +187,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
     for (const elemName in artifact.elements) {
       const origElem = artifact.elements[elemName];
       let elem;
-      if ((isDeprecatedEnabled(options, 'renderVirtualElements') && origElem.virtual) || !origElem.virtual)
+      if ((isDeprecatedEnabled(options, '_renderVirtualElements') && origElem.virtual) || !origElem.virtual)
         elem = copyAndAddElement(origElem, draftsArtifact, draftsArtifactName, elemName)[elemName];
       if (elem) {
         // Remove "virtual" - cap/issues 4956

package/lib/transform/draft/odata.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { forEachDefinition, getUtils, getServiceNames } = require('../../model/csnUtils');
+const { forEachDefinition, getServiceNames } = require('../../model/csnUtils');
 const { forEach } = require('../../utils/objectUtils');
 const { isArtifactInSomeService, getServiceOfArtifact } = require('../odata/utils');
 const { getTransformers } = require('../transformUtilsNew');
@@ -30,15 +30,14 @@ function generateDrafts(csn, options, services) {
     createAssociationElement, createAssociationPathComparison,
     addElement, createAction, assignAction,
     resetAnnotation,
+    csnUtils,
   } = getTransformers(csn, options);
-
   const {
     getFinalType,
     getServiceName,
     hasAnnotationValue,
-    getFinalBaseType,
-    getFinalTypeDef,
-  } = getUtils(csn);
+    getFinalBaseTypeWithProps,
+  } = csnUtils;
 
   const { error, info } = makeMessageFunction(csn, options, 'for.odata');
 
@@ -197,8 +196,8 @@ function generateDrafts(csn, options, services) {
             stack.push(elem);
           }
           else if (elem.type) { // types - possibly structured
-            const typeDef = elem.type.ref ? getFinalBaseType(elem.type) : getFinalTypeDef(elem.type);
-            if (typeDef.elements)
+            const typeDef = getFinalBaseTypeWithProps(elem.type);
+            if (typeDef?.elements)
               stack.push(typeDef);
           }
         });