@cap-js/cds-typer 0.35.0 → 0.36.0

package/lib/components/enum.js

@@ -124,7 +124,6 @@ const isInlineEnumType = (element, csn) => element.enum
  * @param {[string, string][]} kvs - a list of key-value pairs. Values that are falsey are replaced by
  * @param {import('../printers/javascript').Printer} jsp - the printer to use
  */
-// ??= for inline enums. If there is some static property of that name, we don't want to override it (for example: ".actions"
 const stringifyEnumImplementation = (name, kvs, jsp) => jsp.printExport(
     name,
     `{ ${kvs.map(([k,v]) => `${normalise(k)}: ${v}`).join(', ')} }`,

package/lib/resolution/resolver.js

@@ -312,11 +312,24 @@ class Resolver {
                 }[element.constructor.name] ?? []
 
             if (toOne && toMany) {
-                /** @type { EntityCSN | { type: string } } */
-                // @ts-expect-error - nope, it is not undefined
-                const target = element.items ?? (typeof element.target === 'string'
-                    ? { type: element.target }
-                    : element.target)
+                /**
+                 * Resolve a property from a CSN entity. If it is a reference, leave it as is.
+                 * If it is a string, return an object with type set to the string.
+                 * @param {Record<string, any>} el - the element to check
+                 * @param {string} property - the property to check
+                 * @returns {import('../typedefs').resolver.EntityCSN | { type: string }}
+                 */
+                const getTarget = (el, property) => typeof el[property] === 'string'
+                    ? { type: el[property] }
+                    : el[property]
+
+                /** @type { EntityCSN | { type: string } | undefined } */
+                const target = element.items
+                    ?? getTarget(element, 'target')
+                    ?? getTarget(element, 'targetAspect')  // Composition of aspects
+                if (!target) {
+                    throw new Error(`Could not resolve target of ${element}`)
+                }
                 /** set `notNull = true` to avoid repeated `| not null` TS construction */
                 // @ts-expect-error - yes, we know that notNull is not part of the type in some cases
                 target.notNull = true

package/lib/visitor.js

@@ -19,6 +19,7 @@ const { createMember } = require('./components/class')
 const { overrideNameProperty } = require('./printers/javascript')
 
 const baseDefinitions = getBaseDefinitions()
+const MAX_TRANSITIVE_RESOLUTION_STEPS = 10
 
 /** @typedef {import('./file').File} File */
 /** @typedef {import('./typedefs').visitor.Context} Context */
@@ -276,6 +277,31 @@ class Visitor {
                     }))
                     if (typeof e?.type !== 'string' && e?.type?.ref) {
                         e.resolvedType = /** @type {string} */(lookUpRefType(this.csn, e.type.ref)?.type)
+                        try {
+                            /**
+                             * multi-level resolution does not contain a .ref property:
+                             * ```cds
+                             * entity A {
+                             *   x: enum ...
+                             * }
+                             * entity B {
+                             *   x: A:x
+                             * }
+                             * entity C {
+                             *   x: B:x
+                             * }
+                             * ```
+                             * results in B.x having a ref to [A,x], but C.x only has a string 'A.x' as type.
+                             * So we have to do yet another round of resolution on this string.
+                             * We attempt to follow this chain for MAX_TRANSITIVE_RESOLUTION_STEPS tops,
+                             * but we could finish earlier, when the type is a primitive ("string"), which
+                             * then jumps to the catch {} to leave e.resolvedType at the last, resolvable type.
+                             */
+                            for (let i = 0; i < MAX_TRANSITIVE_RESOLUTION_STEPS; i++) {
+                                const { csn } = this.resolver.resolveTypeName(/** @type {string} */(e.resolvedType))
+                                e.resolvedType = csn.type
+                            }
+                        } catch { /* ignore */ }
                     }
                     file.addInlineEnum(clean, fq, e.name, csnToEnumPairs(e, {unwrapVals: true}), buffer, eDoc)
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.35.0",
+  "version": "0.36.0",
   "description": "Generates .ts files for a CDS model to receive code completion in VS Code",
   "main": "index.js",
   "repository": "github:cap-js/cds-typer",
@@ -48,7 +48,7 @@
     "@stylistic/eslint-plugin-js": "^4.2.0",
     "acorn": "^8.10.0",
     "eslint": "^9",
-    "eslint-plugin-jsdoc": "^50.2.2",
+    "eslint-plugin-jsdoc": "^51.2.1",
     "typescript": ">=4.6.4"
   },
   "cds": {