Properly handle reference types to string fields for enums (#452)

CHANGELOG.md

@@ -13,6 +13,7 @@ All notable changes to this project will be documented in this file.
 ### Deprecated
 ### Removed
 ### Fixed
+- referencing another entity's property of type `cds.String` in an enum will not properly quote the generated values
 ### Security
 
 ## [0.31.0] - 2024-12-16

lib/components/enum.js

@@ -67,7 +67,7 @@ function printEnum(buffer, name, kvs, options = {}, doc=[]) {
  * Converts a CSN type describing an enum into a list of kv-pairs.
  * Values from CSN are unwrapped from their `.val` structure and
  * will fall back to the key if no value is provided.
- * @param {import('../typedefs').resolver.EnumCSN} enumCsn - the CSN type describing the enum
+ * @param {import('../typedefs').resolver.EnumCSN & { resolvedType?: string }} enumCsn - the CSN type describing the enum
  * @param {{unwrapVals: boolean} | {}} options - if `unwrapVals` is passed,
  *  then the CSN structure `{val:x}` is flattened to just `x`.
  *  Retaining `val` is closer to the actual CSN structure and should be used where we want
@@ -81,10 +81,10 @@ function printEnum(buffer, name, kvs, options = {}, doc=[]) {
  * csnToEnumPairs(csn, {unwrapVals: false}) // -> [['X', {val:'a'}], ['Y': {val:'b'}], ['Z':'Z']]
  * ```
  */
-const csnToEnumPairs = ({enum: enm, type}, options = {}) => {
+const csnToEnumPairs = ({enum: enm, type, resolvedType}, options = {}) => {
     const actualOptions = {...{unwrapVals: true}, ...options}
     return Object.entries(enm).map(([k, v]) => {
-        const val = enumVal(k, v.val, type)
+        const val = enumVal(k, v.val, resolvedType ?? type)  // if type is a ref, prefer the resolvedType to catch references to cds.Strings
         return [k, (actualOptions.unwrapVals ? val : { val })]
     })
 }

lib/csn.js

@@ -336,6 +336,25 @@ const getProjectionAliases = entity => {
     return { aliases, all }
 }
 
+/**
+ * Heuristic way of looking up a reference type.
+ * We currently only support up to two segments,
+ * the first referring to the entity, a possible second
+ * referring to an element of the entity.
+ * @param {CSN} csn - CSN
+ * @param {string[]} ref - reference
+ * @returns {EntityCSN}
+ */
+function lookUpRefType (csn, ref) {
+    if (ref.length > 2) throw new Error(`Unsupported reference type ${ref.join('.')} with ${ref.length} segments. Please report this error.`)
+    /** @type {EntityCSN | undefined} */
+    let result = csn.definitions[ref[0]]  // entity
+    if (ref.length === 1) return result
+    result = result?.elements?.[ref[1]]  // property
+    if (!result) throw new Error(`Failed to look up reference type ${ref.join('.')}`)
+    return result
+}
+
 module.exports = {
     collectDraftEnabledEntities,
     isView,
@@ -352,5 +371,6 @@ module.exports = {
     getViewTarget,
     propagateForeignKeys,
     propagateInflectionAnnotations,
-    isCsnAny
+    isCsnAny,
+    lookUpRefType
 }

lib/typedefs.d.ts

@@ -48,7 +48,8 @@ export module resolver {
 
 
     export type EnumCSN = EntityCSN & {
-        enum: {[key:name]: string}
+        enum: {[key:name]: string},
+        resolvedType?: string  // custom property! When .type points to a ref, the visitor will resolve the ref into this property
     }
 
     export type CSN = {

lib/visitor.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { propagateForeignKeys, propagateInflectionAnnotations, collectDraftEnabledEntities, isDraftEnabled, isType, getMaxCardinality, isViewOrProjection, isEnum, isEntity } = require('./csn')
+const { propagateForeignKeys, propagateInflectionAnnotations, collectDraftEnabledEntities, isDraftEnabled, isType, getMaxCardinality, isViewOrProjection, isEnum, isEntity, lookUpRefType } = require('./csn')
 // eslint-disable-next-line no-unused-vars
 const { SourceFile, FileRepository, Buffer, Path } = require('./file')
 const { FlatInlineDeclarationResolver, StructuredInlineDeclarationResolver } = require('./components/inline')
@@ -272,6 +272,9 @@ class Visitor {
                         initialiser: propertyToInlineEnumName(clean, e.name),
                         isStatic: true,
                     }))
+                    if (typeof e?.type !== 'string' && e?.type?.ref) {
+                        e.resolvedType = /** @type {string} */(lookUpRefType(this.csn, e.type.ref)?.type)
+                    }
                     file.addInlineEnum(clean, fq, e.name, csnToEnumPairs(e, {unwrapVals: true}), buffer, eDoc)
                 }
 

test/unit/files/enums/model.cds

@@ -49,3 +49,7 @@ entity ExternalEnums {
     gender: Gender;
     yesno: Truthy;
 }
+
+entity ReferingType {
+    gender: type of InlineEnums : gender
+}