@cap-js/cds-typer 0.19.0 → 0.20.1

package/lib/visitor.js

@@ -4,18 +4,20 @@ const util = require('./util')
 
 const { amendCSN, isView, isUnresolved, propagateForeignKeys, isDraftEnabled, isType, isProjection } = require('./csn')
 // eslint-disable-next-line no-unused-vars
-const { SourceFile, FileRepository, baseDefinitions, Buffer } = require('./file')
+const { SourceFile, FileRepository, Buffer } = require('./file')
 const { FlatInlineDeclarationResolver, StructuredInlineDeclarationResolver } = require('./components/inline')
 const { Resolver, resolveBuiltin } = require('./components/resolver')
 const { Logger } = require('./logging')
 const { docify } = require('./components/wrappers')
 const { csnToEnumPairs, propertyToInlineEnumName, isInlineEnumType, stringifyEnumType } = require('./components/enum')
 const { isReferenceType } = require('./components/reference')
+const { empty } = require('./components/typescript')
+const { baseDefinitions } = require('./components/basedefs')
 
- /** @typedef {import('./file').File} File */
- /** @typedef {{ entity: String }} Context */
+/** @typedef {import('./file').File} File */
+/** @typedef {{ entity: String }} Context */
 
- /** 
+/** 
  * @typedef { {
  *    rootDirectory: string, 
  *    logLevel: number, 
@@ -23,7 +25,7 @@ const { isReferenceType } = require('./components/reference')
  * }} CompileParameters
  */
 
- /** 
+/** 
  * - `propertiesOptional = true` -> all properties are generated as optional ?:. (standard CAP behaviour, where properties be unavailable)
  * - `inlineDeclarations = 'structured'` -> @see inline.StructuredInlineDeclarationResolver
  * - `inlineDeclarations = 'flat'` -> @see inline.FlatInlineDeclarationResolver
@@ -33,7 +35,7 @@ const { isReferenceType } = require('./components/reference')
  * }} VisitorOptions 
  */
 
- /**
+/**
   * @typedef {{
   *   typeName: string,
   *   singular: string,
@@ -153,10 +155,10 @@ class Visitor {
      */
     #aspectify(name, entity, buffer, options = {}) {
         const clean = options?.cleanName ?? this.resolver.trimNamespace(name)
-        const ns = this.resolver.resolveNamespace(name.split('.'))
-        const file = this.fileRepository.getNamespaceFile(ns)
-        const identSingular = (name) => name
-        const identAspect = (name) => `_${name}Aspect`
+        const namespace = this.resolver.resolveNamespace(name.split('.'))
+        const file = this.fileRepository.getNamespaceFile(namespace)
+        const identSingular = name => name
+        const identAspect = name => `_${name}Aspect`
 
         this.contexts.push({ entity: name })
 
@@ -201,36 +203,45 @@ class Visitor {
                         file.addInlineEnum(clean, name, e.name, csnToEnumPairs(e, {unwrapVals: true}))
                     }
                     const actions = Object.entries(entity.actions ?? {})
-                    buffer.addIndentedBlock('static actions: {', 
-                        actions.map(([aname, action]) => SourceFile.stringifyLambda({
-                            name: aname,
-                            parameters: this.#stringifyFunctionParams(action.params, file),
-                            returns: action.returns ? this.resolver.resolveAndRequire(action.returns, file).typeName : 'any'
-                        }))
-                    , '}') // end of actions
+                    if (actions.length) {
+                        buffer.addIndentedBlock('static readonly actions: {', 
+                            actions.map(([aname, action]) => SourceFile.stringifyLambda({
+                                name: aname,
+                                parameters: this.#stringifyFunctionParams(action.params, file),
+                                returns: action.returns ? this.resolver.resolveAndRequire(action.returns, file).typeName : 'any',
+                                kind: action.kind
+                            }))
+                            , '}') // end of actions
+                    } else {
+                        buffer.add(`static readonly actions: ${empty}`)
+                    }
                 }.bind(this))
             }.bind(this), '};') // end of generated class
         }.bind(this), '}') // end of aspect
 
         // CLASS WITH ADDED ASPECTS
         file.addImport(baseDefinitions.path)
-        const rhs = (entity.includes ?? [])
-            .map((parent) => {
-                const [ns, n] = this.resolver.untangle(parent)
-                file.addImport(ns)
-                return [ns, n]
+        const ancestors = (entity.includes ?? [])
+            .map(parent => {
+                const { namespace, name } = this.resolver.untangle(parent)
+                file.addImport(namespace)
+                return [namespace, name, parent]
             })
-            .concat([[undefined, clean]]) // add own aspect without namespace AFTER imports were created
+            .concat([[undefined, clean, [namespace, clean].filter(Boolean).join('.')]]) // add own aspect without namespace AFTER imports were created
             .reverse() // reverse so that own aspect A is applied before extensions B,C: B(C(A(Entity)))
-            .reduce(
-                (wrapped, [ns, n]) =>
-                    !ns || ns.isCwd(file.path.asDirectory())
-                        ? `${identAspect(n)}(${wrapped})`
-                        : `${ns.asIdentifier()}.${identAspect(n)}(${wrapped})`,
-                `${baseDefinitions.path.asIdentifier()}.Entity`
+            .reduce((wrapped, [ns, n, fq]) => {
+                // types are not inflected, so don't change those to singular
+                const refersToType = isType(this.csn.inferred.definitions[fq])
+                const ident = identAspect(refersToType ? n : util.singular4(n))
+
+                return !ns || ns.isCwd(file.path.asDirectory())
+                    ? `${ident}(${wrapped})`
+                    : `${ns.asIdentifier()}.${ident}(${wrapped})` 
+            },
+            `${baseDefinitions.path.asIdentifier()}.Entity`
             )
 
-        buffer.add(`export class ${identSingular(clean)} extends ${rhs} {${this.#staticClassContents(clean, entity).join('\n')}}`)
+        buffer.add(`export class ${identSingular(clean)} extends ${ancestors} {${this.#staticClassContents(clean, entity).join('\n')}}`)
         //buffer.add(`export type ${clean} = InstanceType<typeof ${identSingular(clean)}>`)
         this.contexts.pop()
     }
@@ -242,7 +253,7 @@ class Visitor {
     #printEntity(name, entity) {
         // static .name has to be defined more forcefully: https://github.com/microsoft/TypeScript/issues/442
         const overrideNameProperty = (clazz, content) => `Object.defineProperty(${clazz}, 'name', { value: '${content}' })`
-        const [ns, clean] = this.resolver.untangle(name)
+        const { namespace: ns, name: clean } = this.resolver.untangle(name)
         const file = this.fileRepository.getNamespaceFile(ns)
         // entities are expected to be in plural anyway, so we would favour the regular name.
         // If the user decides to pass a @plural annotation, that gets precedence over the regular name.
@@ -251,21 +262,19 @@ class Visitor {
         let plural = this.resolver.trimNamespace(util.getPluralAnnotation(entity) ? util.plural4(entity, false) : name)
         const singular = this.resolver.trimNamespace(util.singular4(entity, true))
         */
-       let { singular, plural } = this.resolver.inflect({csn: entity, plainName: clean}, ns.asNamespace())
+        let { singular, plural } = this.resolver.inflect({csn: entity, plainName: clean}, ns.asNamespace())
 
         // trimNamespace does not properly detect scoped entities, like A.B where both A and B are
         // entities. So to see if we would run into a naming collision, we forcefully take the last
         // part of the name, so "A.B" and "A.Bs" just become "B" and "Bs" to be compared.
         // FIXME: put this in a util function
-        //if (singular.split('.').at(-1) === plural.split('.').at(-1)) {
         if (plural.split('.').at(-1) === `${singular.split('.').at(-1)}_`) {
-            //plural += '_'
             this.logger.warning(
                 `Derived singular and plural forms for '${singular}' are the same. This usually happens when your CDS entities are named following singular flexion. Consider naming your entities in plural or providing '@singular:'/ '@plural:' annotations to have a clear distinction between the two. Plural form will be renamed to '${plural}' to avoid compilation errors within the output.`
             )
         }
-        // as types are not inflected, their singular will always clash and there is also no plural for them anyway
-        if (!isType(entity) && singular in this.csn.xtended.definitions) {
+        // as types are not inflected, their singular will always clash and there is also no plural for them anyway -> skip
+        if (!isType(entity) && `${ns.asNamespace()}.${singular}` in this.csn.xtended.definitions) {
             this.logger.error(
                 `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.`
             )
@@ -285,7 +294,7 @@ class Visitor {
         // which would not be possible while already in singular form, as "Book.text" could not be resolved in CSN.
         // edge case: @singular annotation present. singular4 will take care of that.
         file.addInflection(util.singular4(entity, true), plural, clean)
-        docify(entity.doc).forEach(d => buffer.add(d))
+        docify(entity.doc).forEach(d => { buffer.add(d) })
 
         // in case of projections `entity` is empty -> retrieve from inferred csn where the actual properties are rolled out
         const target = isProjection(entity) || isView(entity)
@@ -309,7 +318,9 @@ class Visitor {
             }
             // plural can not be a type alias to $singular[] but needs to be a proper class instead,
             // so it can get passed as value to CQL functions.
-            buffer.add(`export class ${plural} extends Array<${singular}> {${this.#staticClassContents(singular, entity).join('\n')}}`)
+            const additionalProperties = this.#staticClassContents(singular, entity)
+            additionalProperties.push('$count?: number')
+            buffer.add(`export class ${plural} extends Array<${singular}> {${additionalProperties.join('\n')}}`)
             buffer.add(overrideNameProperty(plural, entity.name))
         }
         buffer.add('')
@@ -338,39 +349,42 @@ class Visitor {
     #stringifyFunctionParamType(type, file) {
         // 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 && resolveBuiltin(type.type)
-            ? stringifyEnumType(csnToEnumPairs(type))
-            : this.inlineDeclarationResolver.getPropertyDatatype(this.resolver.resolveAndRequire(type, file))
-    }
-
-    #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.fileRepository.getNamespaceFile(ns)
-        const params = this.#stringifyFunctionParams(func.params, file)
-        const returns = this.resolver.visitor.inlineDeclarationResolver.getPropertyDatatype(
-            this.resolver.resolveAndRequire(func.returns, file)
+        if (type.enum && resolveBuiltin(type.type)) return stringifyEnumType(csnToEnumPairs(type))
+        const paramType = this.resolver.resolveAndRequire(type, file)
+        return this.inlineDeclarationResolver.getPropertyDatatype(
+            paramType,
+            paramType.typeInfo.isArray ? paramType.typeName : paramType.typeInfo.inflection.singular
         )
-        file.addFunction(name.split('.').at(-1), params, returns)
     }
 
-    #printAction(name, action) {
-        this.logger.debug(`Printing action ${name}:\n${JSON.stringify(action, null, 2)}`)
+    /**
+     * @param {string} name
+     * @param {object} operation
+     * @param {'function' | 'action'} kind
+     */
+    #printOperation(name, operation, kind) {
+        this.logger.debug(`Printing operation ${name}:\n${JSON.stringify(operation, null, 2)}`)
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.fileRepository.getNamespaceFile(ns)
-        const params = this.#stringifyFunctionParams(action.params, file)
-        const returns = this.resolver.visitor.inlineDeclarationResolver.getPropertyDatatype(
-            this.resolver.resolveAndRequire(action.returns, file)
+        const params = this.#stringifyFunctionParams(operation.params, file)
+        const returnType = operation.returns
+            ? this.resolver.resolveAndRequire(operation.returns, file)
+            : { typeName: 'void', typeInfo: { isArray: false, inflection: { singular: 'void', plural: 'void' } } }
+        const returns = this.inlineDeclarationResolver.getPropertyDatatype(
+            returnType,
+            returnType.typeInfo.isArray ? returnType.typeName : returnType.typeInfo.inflection.singular
         )
-        file.addAction(name.split('.').at(-1), params, returns)
+        file.addOperation(name.split('.').at(-1), params, returns, kind)
     }
 
     #printType(name, type) {
         this.logger.debug(`Printing type ${name}:\n${JSON.stringify(type, null, 2)}`)
-        const [ns, clean] = this.resolver.untangle(name)
+        const { namespace: ns, name: clean } = this.resolver.untangle(name)
         const file = this.fileRepository.getNamespaceFile(ns)
-        if ('enum' in type && !isReferenceType(type)) {  // skip references to enums
+        // skip references to enums.
+        // "Base" enums will always have a builtin type (don't skip those).
+        // A type referencing an enum E will be considered an enum itself and have .type === E (skip).
+        if ('enum' in type && !isReferenceType(type) && resolveBuiltin(type.type)) {
             file.addEnum(name, clean, csnToEnumPairs(type))
         } else {
             // alias
@@ -381,7 +395,7 @@ class Visitor {
 
     #printAspect(name, aspect) {
         this.logger.debug(`Printing aspect ${name}`)
-        const [ns, clean] = this.resolver.untangle(name)
+        const { namespace: ns, name: clean } = this.resolver.untangle(name)
         const file = this.fileRepository.getNamespaceFile(ns)
         // aspects are technically classes and can therefore be added to the list of defined classes.
         // Still, when using them as mixins for a class, they need to already be defined.
@@ -393,7 +407,7 @@ class Visitor {
 
     #printEvent(name, event) {
         this.logger.debug(`Printing event ${name}`)
-        const [ns, clean] = this.resolver.untangle(name)
+        const { namespace: ns, name: clean } = this.resolver.untangle(name)
         const file = this.fileRepository.getNamespaceFile(ns)
         file.addEvent(clean, name)
         const buffer = file.events.buffer
@@ -425,33 +439,31 @@ class Visitor {
      */
     visitEntity(name, entity) {
         switch (entity.kind) {
-            case 'entity':
-                this.#printEntity(name, entity)
-                break
-            case 'action':
-                this.#printFunction(name, entity)
-                break
-            case 'function':
-                this.#printAction(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.call(this, name, entity)
-                break
-            }
-            case 'event':
-                this.#printEvent(name, entity)
-                break
-            case 'service':
-                this.#printService(name, entity)
-                break
-            default:
-                this.logger.debug(`Unhandled entity kind '${entity.kind}'.`)
+        case 'entity':
+            this.#printEntity(name, entity)
+            break
+        case 'action':
+        case 'function':
+            this.#printOperation(name, entity, entity.kind)
+            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.call(this, name, entity)
+            break
+        }
+        case 'event':
+            this.#printEvent(name, entity)
+            break
+        case 'service':
+            this.#printService(name, entity)
+            break
+        default:
+            this.logger.debug(`Unhandled entity kind '${entity.kind}'.`)
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "description": "Generates .ts files for a CDS model to receive code completion in VS Code",
   "main": "index.js",
   "repository": "github:cap-js/cds-typer",
@@ -40,10 +40,10 @@
     "@sap/cds": ">=7.7"
   },
   "devDependencies": {
-    "@babel/eslint-parser": "^7.23.3",
     "@stylistic/eslint-plugin-js": "^1.6.3",
     "acorn": "^8.10.0",
-    "eslint": "^8.15.0",
+    "eslint": "^9",
+    "globals": "^15.0.0",
     "jest": "^29",
     "typescript": ">=4.6.4"
   },