@cap-js/cds-typer 0.35.0 → 0.37.0

package/lib/boilerplate/tsBoilerplate.ts

@@ -72,7 +72,7 @@ export type CdsMap = { [key: string]: unknown };
 
 
 export const createEntityProxy = function (fqParts: any, opts = {}) {
-    const { target, customProps } = { target: {}, customProps: [], ...opts }
+    const { target, customProps } = { target: {}, customProps: [] as any[], ...opts }
     const fq = fqParts.filter((p: any) => !!p).join('.')
     return new Proxy(target, {
         get: function (target:any, prop:any) {

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/components/property.js

@@ -1,11 +1,15 @@
 /**
  * Determines the proper modifiers for a property.
- * For most properties, this will be "declare". But for some properties,
- * like fields of a type, we don't want any modifiers.
+ *
+ * All properties must be modified by `declare`.
+ * The only exception to this is in case of an action return type being defined
+ * as an object. Here `declare` would cause an error.
+ * This case can be identified by checking the parent of the property:
+ * If the parent is a type and has no name, then it is an action return type.
  * @param {import('../typedefs').resolver.EntityCSN} element - The element to determine the modifiers for.
  * @returns {import('../typedefs').resolver.PropertyModifier[]} The modifiers for the property.
  */
-const getPropertyModifiers = element => element?.parent?.kind !== 'type' ? ['declare'] : []
+const getPropertyModifiers = element => element?.parent?.kind === 'type' && element?.parent?.name === undefined ? [] : ['declare']
 
 module.exports = {
     getPropertyModifiers

package/lib/csn.js

@@ -65,6 +65,11 @@ const isEntity = entity => entity?.kind === 'entity'
  */
 const isEnum = entity => Boolean(entity && Object.hasOwn(entity, 'enum'))
 
+/**
+ * @param {EntityCSN & { '@cds.external'?: boolean } | undefined} entity - the entity
+ */
+const isExternal = entity => entity?.['@cds.external'] === true
+
 /**
  * Attempts to retrieve the max cardinality of a CSN for an entity.
  * @param {EntityCSN} element - csn of entity to retrieve cardinality for
@@ -365,6 +370,7 @@ module.exports = {
     isEnum,
     isUnresolved,
     isType,
+    isExternal,
     getMaxCardinality,
     getProjectionTarget,
     getProjectionAliases,

package/lib/file.js

@@ -162,6 +162,7 @@ class SourceFile extends File {
      * @param {string} options.name - name of the lambda
      * @param {import('./typedefs').visitor.ParamInfo[]} [options.parameters] - list of parameters, passed as [name, modifier, type, doc] pairs
      * @param {string} [options.returns] - the return type of the function
+     * @param {string} [options.self] - what is set as "__self", which is used for bound actions
      * @param {'action' | 'function'} options.kind - kind of the lambda
      * @param {string} [options.initialiser] - the initialiser expression
      * @param {boolean} [options.isStatic] - whether the lambda is static
@@ -187,7 +188,7 @@ class SourceFile extends File {
      * stringifyLambda({name: 'f', parameters: [{name:'p',type:'T'}], returns: 'number'})  // { (p: T): number, __parameters: { p: T } }
      * ```
      */
-    static stringifyLambda({name, parameters=[], returns='any', kind, initialiser, isStatic=false, callStyles={positional:true, named:true}, doc}) {
+    static stringifyLambda({name, parameters=[], returns='any', kind, initialiser, self='null', isStatic=false, callStyles={positional:true, named:true}, doc}) {
         let docStr = doc?.length ? doc.join('\n')+'\n' : ''
         const parameterTypes = parameters.map(({name, modifier, type, doc}) => `${doc?'\n'+doc:''}${normalise(name)}${modifier}: ${type}`).join(', ')
         const parameterTypeAsObject = parameterTypes.length
@@ -212,7 +213,7 @@ class SourceFile extends File {
 
         return [
             `${prefix} {`,
-            [...callableSignatures, '// metadata (do not use)', `__parameters: ${parameterTypeAsObject}, __returns: ${returns}`, ...kindDef],
+            [...callableSignatures, '// metadata (do not use)', `__parameters: ${parameterTypeAsObject}, __returns: ${returns}, __self: ${self}`, ...kindDef],
             `}${suffix}`,
         ]
     }

package/lib/resolution/resolver.js

@@ -7,7 +7,7 @@ const { deepRequire, createToManyAssociation, createToOneAssociation, createArra
 const { StructuredInlineDeclarationResolver } = require('../components/inline')
 const { isInlineEnumType, propertyToInlineEnumName } = require('../components/enum')
 const { isReferenceType } = require('../components/reference')
-const { isEntity, getMaxCardinality } = require('../csn')
+const { isEntity, getMaxCardinality, isExternal } = require('../csn')
 const { getBaseDefinitions } = require('../components/basedefs')
 const { BuiltinResolver } = require('./builtin')
 const { LOG } = require('../logging')
@@ -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
@@ -536,10 +549,11 @@ class Resolver {
             result.isBuiltin = true
             this.resolveType(element.items, file)
             //delete element.items
-        } else if (!result.isBuiltin && element?.elements && (options?.forceInlineStructs || !element?.type)) {
+        } else if (!result.isBuiltin && !isExternal(element) && element?.elements && (options?.forceInlineStructs || !element?.type)) {
             // explicitly skip named type definitions, which have elements too, but should not be considered inline declarations
             // if the resolver option `forceInlineStructs` is `true`, named types in elements will be converted to inline
             // Skipping isBuiltin will skip cds.Map, which has elements
+            // Skipping isExternal will skip @cds.external entities, which have elements as well
             this.#resolveInlineDeclarationType(element.elements, result, file, options)
         }
 

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 */
@@ -94,11 +95,12 @@ class Visitor {
 
     /**
      * @param {EntityCSN} entity - the entity to print the actions for
+     * @param {string} clean - the clean entity name
      * @param {Buffer} buffer - the buffer to write the actions into
      * @param {import('./typedefs').resolver.EntityInfo[]} ancestors - the fully qualified names of the ancestors of the entity
      * @param {SourceFile} file - the file the entity is being printed into
      */
-    #printStaticActions(entity, buffer, ancestors, file) {
+    #printStaticActions(entity, clean, buffer, ancestors, file) {
         // TODO: refactor away! All these printing functionalities need to go
         const actions = Object.entries(entity.actions ?? {})
         const inherited = ancestors.map(a => `typeof ${asIdentifier({info: a, relative: file.path})}.actions`)
@@ -109,6 +111,7 @@ class Visitor {
                 () => {
                     for (const [aname, action] of actions) {
                         const [opener, content, closer] = SourceFile.stringifyLambda({
+                            self: clean,
                             name: aname,
                             parameters: this.#stringifyFunctionParams(action.params, file),
                             returns: action.returns
@@ -276,6 +279,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)
                 }
@@ -293,7 +321,7 @@ class Visitor {
                 }
                 this.#printStaticKeys(buffer, clean, ancestorInfos, file)
                 this.#printStaticElements(buffer, clean)
-                this.#printStaticActions(entity, buffer, ancestorInfos, file)
+                this.#printStaticActions(entity, clean, buffer, ancestorInfos, file)
             }, '};') // end of generated class
         }, '}') // end of aspect
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.35.0",
+  "version": "0.37.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": {