@cap-js/cds-typer 0.36.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/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')
@@ -549,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

@@ -95,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`)
@@ -110,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
@@ -319,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.36.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",