@cap-js/cds-typer 0.6.1 → 0.8.0

package/CHANGELOG.md

@@ -4,12 +4,34 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
-## Version 0.6.2 - TBD
+## Version 0.8.1 - TBD
 
 ### Changed
 
 ### Added
 
+### Fixed
+
+
+## Version 0.8.0 - 2023-09-05
+
+### Changed
+
+### Added
+
+### Fixed
+- Foreign keys that are inherited via aspects are now also generated in addition to the resolved property (see 0.7.0)
+- Explicitly annotated `@singular` and `@plural` names are now properly used in generated _index.js_ files
+
+
+## Version 0.7.0 - 2023-08-22
+
+### Changed
+
+### Added
+- Support for `[many] $self` syntax in bound action parameters
+- Foreign keys are now present in the generated types in addition to the resolved property
+
 ### Fixed
 ## Version 0.6.1 - 2023-08-10
 

package/lib/components/resolver.js

@@ -445,6 +445,10 @@ class Resolver {
             result.path = new Path(path) // FIXME: relative to current file
             result.csn = this.csn.definitions[t]
             result.plainName = this.trimNamespace(t)
+        } else if (t === '$self') {
+            result.type = 'this'
+            result.isBuiltin = true
+            result.plainName = 'this'
         } else {
             // type offered by some library
             const lib = this.libraries.find((lib) => lib.offers(t))

package/lib/file.js

@@ -335,6 +335,9 @@ class SourceFile extends File {
                     .flatMap(([singular, plural, original]) => Array.from(new Set([
                         `module.exports.${singular} = csn.${original}`,
                         `module.exports.${plural} = csn.${original}`,
+                        // FIXME: we currently produce at most 3 entries.
+                        // This could be an issue when the user re-used the original name in a @singular/@plural annotation.
+                        // Seems unlikely, but we have to eliminate the original entry if users start running into this.
                         `module.exports.${original} = csn.${original}`
                     ])))
             ) // singular -> plural aliases

package/lib/util.js

@@ -201,6 +201,24 @@ const parseCommandlineArgs = (argv, validFlags) => {
 * when removing an annotation which we also check.
 */
 function fixCSN(csn) {
+    for (const element of Object.values(csn.definitions)) {
+        Object.defineProperty(element, 'keys', {
+            get: function () {
+                // cached access to all immediately defined _and_ inherited keys.
+                // They need to be explicitly accessible in subclasses to generate
+                // foreign key fields from Associations/ Compositions.
+                if (!Object.hasOwn(this, '__keys')) {
+                    const ownKeys = Object.fromEntries(Object.entries(this.elements ?? {}).filter(([,el]) => el.key === true))
+                    const inheritedKeys = this.includes?.flatMap(parent => csn.definitions[parent].keys) ?? []
+                    this.__keys = inheritedKeys.reduce((ks, ps) => ({...ps, ...ks}), ownKeys)
+                }
+                return this.__keys
+            }
+        })
+    }
+
+    // FIXME: delete after merge with draft-enablement PR
+    return
     const erase = (entity, parent, attr) => {
         if (attr in entity) {
             const ea = entity[attr]

package/lib/visitor.js

@@ -130,16 +130,21 @@ class Visitor {
         buffer.indent()
         for (const [ename, element] of Object.entries(entity.elements ?? {})) {
             this.visitElement(ename, element, file, buffer)
+            // make foreign keys explicit
+            if ('target' in element) {
+                // lookup in cds.definitions can fail for inline structs.
+                // We don't really have to care for this case, as keys from such structs are _not_ propagated to
+                // the containing entity.
+                for (const [kname, kelement] of Object.entries(this.csn.definitions[element.target]?.keys ?? {})) {
+                    this.visitElement(`${ename}_${kname}`, kelement, file, buffer)
+                }
+            }
         }
         for (const [aname, action] of Object.entries(entity.actions ?? {})) {
-            const lambdaString = 
             buffer.add(
                 SourceFile.stringifyLambda({
                     name: aname,
-                    parameters: Object.entries(action.params ?? {}).map(([n, t]) => [
-                        n,
-                        this.resolver.resolveAndRequire(t, file).typeName,
-                    ]),
+                    parameters: this.#stringifyFunctionParams(action.params, file),
                     returns: action.returns ? this.resolver.resolveAndRequire(action.returns, file).typeName : 'any',
                     initialiser: `undefined as unknown as this['${aname}']`
                 })
@@ -208,7 +213,8 @@ class Visitor {
         // to have Books.texts = Books.text, so we derive the singular once more without cutting off the ns.
         // Directly deriving it from the plural makes sure we retain any parent namespaces of kind "entity",
         // which would not be possible while already in singular form, as "Book.text" could not be resolved in CSN.
-        file.addInflection(util.singular4(plural), plural, clean)
+        // edge case: @singular annotation present. singular4 will take care of that.
+        file.addInflection(util.singular4(entity, true), plural, clean)
         if ('doc' in entity) {
             docify(entity.doc).forEach((d) => buffer.add(d))
         }
@@ -226,17 +232,32 @@ class Visitor {
         buffer.add('')
     }
 
+    /**
+     * Stringifies function parameters in preparation of passing them to {@link SourceFile.stringifyLambda}.
+     * Resolves all parameters to a pair of parameter name and name of the resolved type.
+     * Also filters out parameters that indicate a binding parameter ({@link https://cap.cloud.sap/docs/releases/jan23#simplified-syntax-for-binding-parameters}).
+     * @param {[string, object][]} params - parameter list as found in CSN.
+     * @param {File} file - source file relative to which the parameter types should be resolved.
+     * @returns {[string, string][]} pair of names and types.
+     */
+    #stringifyFunctionParams(params, file) {
+        return params
+            ? Object.entries(params)
+                // filter params of type '[many] $self', as they are not to be part of the implementation
+                .filter(([, type]) => type?.type !== '$self' && !(type.items?.type === '$self'))
+                .map(([name, type]) => [
+                    name,
+                    this.resolver.resolveAndRequire(type, file).typeName,
+                ])
+            : []
+    }
+
     #printFunction(name, func) {
         // FIXME: mostly duplicate of printAction -> reuse
         this.logger.debug(`Printing function ${name}:\n${JSON.stringify(func, null, 2)}`)
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
-        const params = func.params
-            ? Object.entries(func.params).map(([pname, ptype]) => [
-                  pname,
-                  this.resolver.resolveAndRequire(ptype, file).typeName,
-              ])
-            : []
+        const params = this.#stringifyFunctionParams(func.params, file)
         const returns = this.resolver.resolveAndRequire(func.returns, file).typeName
         file.addFunction(name.split('.').at(-1), params, returns)
     }
@@ -245,12 +266,7 @@ class Visitor {
         this.logger.debug(`Printing action ${name}:\n${JSON.stringify(action, null, 2)}`)
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
-        const params = action.params
-            ? Object.entries(action.params).map(([pname, ptype]) => [
-                  pname,
-                  this.resolver.resolveAndRequire(ptype, file).typeName,
-              ])
-            : []
+        const params = this.#stringifyFunctionParams(action.params, file)
         const returns = this.resolver.resolveAndRequire(action.returns, file).typeName
         file.addAction(name.split('.').at(-1), params, returns)
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.6.1",
+  "version": "0.8.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",
@@ -43,6 +43,7 @@
     "@sap/cds": ">=6"
   },
   "devDependencies": {
+    "acorn": "^8.10.0",
     "eslint": "^8.15.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.0.0",