@cap-js/cds-typer 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -4,7 +4,16 @@ 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.16.0 - TBD
+## Version 0.17.0 - TBD
+
+## Version 0.16.0 - 2024-02-01
+### Changed
+- Changed default log level from `NONE` to `ERROR`. See the doc to manually pass in another log level for cds-typer runs
+- Name collisions between automatically generated foreign key fields (`.…_ID`, `.…_code`, etc.) with explicitly named fields will now raise an error
+- Generate CDS types that are actually structured types as if they were entities. This allows the correct representation of mixing aspects and types in CDS inheritance, and also fixes issues with inline enums in such types
+
+### Fixed
+- Externally defined enums can now be used as parameter types in actions
 
 ## Version 0.15.0 - 2023-12-21
 ### Added

package/lib/cli.js

@@ -23,7 +23,7 @@ const flags = {
     logLevel: {
         desc: `Minimum log level that is printed.`,
         allowed: Object.keys(Levels),
-        default: Object.keys(Levels).at(-1),
+        default: Levels.ERROR,
     },
     jsConfigPath: {
         desc: `Path to where the jsconfig.json should be written.${EOL}If specified, ${toolName} will create a jsconfig.json file and${EOL}set it up to restrict property usage in types entities to${EOL}existing properties only.`,
@@ -90,7 +90,7 @@ const main = async (args) => {
     compileFromFile(args.positional, {
         // temporary fix until rootDir is faded out
         outputDirectory: [args.named.outputDirectory, args.named.rootDir].find(d => d !== './') ?? './',
-        logLevel: Levels[args.named.logLevel],
+        logLevel: Levels[args.named.logLevel] ?? args.named.logLevel,
         jsConfigPath: args.named.jsConfigPath,
         inlineDeclarations: args.named.inlineDeclarations,
         propertiesOptional: args.named.propertiesOptional === 'true'

package/lib/components/enum.js

@@ -59,7 +59,7 @@ const stringifyEnumType = kvs => [...uniqueValues(kvs)].join(' | ')
 const uniqueValues = kvs => new Set(kvs.map(([,v]) => v?.val ?? v))  // in case of wrapped vals we need to unwrap here for the type
 
 // in case of strings, wrap in quotes and fallback to key to make sure values are attached for every key
-const enumVal = (key, value, enumType) => enumType === 'cds.String' ? JSON.stringify(`${value ?? key}`) : value
+const  enumVal = (key, value, enumType) => enumType === 'cds.String' ? JSON.stringify(`${value ?? key}`) : value
 
 /**
  * Converts a CSN type describing an enum into a list of kv-pairs.

package/lib/components/resolver.js

@@ -373,7 +373,15 @@ class Resolver {
             if (isInlineEnumType(element, this.csn)) {
                 // element.parent is only set if the enum is attached to an entity's property.
                 // If it is missing then we are dealing with an inline parameter type of an action.
-                if (element.parent) {
+                // Edge case: element.parent is set, but no .name property is attached. This happens
+                // for inline enums inside types:
+                // ```cds
+                // type T {
+                //   x : String enum { ... };  // no element.name for x
+                // }
+                // ```
+                // In that case, we currently resolve to the more general type (cds.String, here)
+                if (element.parent?.name) {
                     result.isInlineDeclaration = true
                     // we use the singular as the initial declaration of these enums takes place
                     // while defining the singular class. Which therefore uses the singular over the plural name.

package/lib/visitor.js

@@ -189,8 +189,13 @@ class Visitor {
                 // the containing entity.
                 for (const [kname, kelement] of this.#keys(element.target)) {
                     if (this.resolver.getMaxCardinality(element) === 1) {
-                        kelement.isRefNotNull = !!element.notNull || !!element.key
-                        this.visitElement(`${ename}_${kname}`, kelement, file, buffer)
+                        const foreignKey = `${ename}_${kname}`
+                        if (Object.hasOwn(entity.elements, foreignKey)) {
+                            this.logger.error(`Attempting to generate a foreign key reference called '${foreignKey}' in type definition for entity ${name}. But a property of that name is already defined explicitly. Consider renaming that property.`)
+                        } else {
+                            kelement.isRefNotNull = !!element.notNull || !!element.key
+                            this.visitElement(foreignKey, kelement, file, buffer)
+                        }
                     }
                 }
             }
@@ -280,7 +285,7 @@ class Visitor {
         }
         if (singular in this.csn.xtended.definitions) {
             this.logger.error(
-                `Derived singular '${singular}' for your entity '${name}', already exists. The resulting types will be erronous. Please consider using '@singular:'/ '@plural:' annotations in your model to resolve this collision.`
+                `Derived singular '${singular}' for your entity '${name}', already exists. The resulting types will be erronous. Consider using '@singular:'/ '@plural:' annotations in your model or move the offending declarations into different namespaces to resolve this collision.`
             )
         }
         file.addClass(singular, name)
@@ -338,7 +343,9 @@ class Visitor {
     }
 
     #stringifyFunctionParamType(type, file) {
-        return type.enum
+        // if type.type is not 'cds.String', 'cds.Integer', ..., then we are actually looking
+        // at a named enum type. In that case also resolve that type name
+        return type.enum && type.type.startsWith('cds.')
             ? stringifyEnumType(csnToEnumPairs(type))
             : this.inlineDeclarationResolver.getPropertyDatatype(this.resolver.resolveAndRequire(type, file))
     }
@@ -439,12 +446,16 @@ class Visitor {
             case 'function':
                 this.#printAction(name, entity)
                 break
-            case 'type':
-                this.#printType(name, entity)
-                break
             case 'aspect':
                 this.#printAspect(name, entity)
                 break
+            case 'type': {
+                // types like inline definitions can be used very similarly to entities.
+                // They can be extended, contain inline enums, etc., so we treat them as entities.
+                const handler = entity.elements ? this.#printEntity : this.#printType
+                handler.bind(this)(name, entity)
+                break
+            }
             case 'event':
                 this.#printEvent(name, entity)
                 break
@@ -452,7 +463,7 @@ class Visitor {
                 this.#printService(name, entity)
                 break
             default:
-                this.logger.error(`Unhandled entity kind '${entity.kind}'.`)
+                this.logger.debug(`Unhandled entity kind '${entity.kind}'.`)
         }
     }
 

package/package.json

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