@cap-js/cds-typer 0.9.0 → 0.11.0

package/CHANGELOG.md

@@ -4,10 +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.9.1 - TBD
+## Version 0.12.0 - TBD
 
 ### Changed
 
+### Added
+### Fixed
+
+## Version 0.11.0 - 2023-10-10
+
+### Changed
+
+### Added
+- Autoexposed entities in services are now also generated
+- Each generated class now contains their original fully qualified name in a static `.name` property
+- Inline enums that are defined as literal type of properties are now supported as well (note: this feature is experimental. The location to which enums are generated might change in the future!)
+
+### Fixed
+- Fixed an error when an entity uses `type of` on a property they have inherited from another entity
+- Fixed an error during draftability propagation when defining compositions on types that are declared inline
+
+### Removed
+- `compileFromCSN` is no longer part of the package's API
+
+## Version 0.10.0 - 2023-09-21
+
+### Changed
+- Actions and functions are now attached to a static `.actions` property of each generated class. This reflects the runtime behaviour better than the former way of generating instance methods
+
 ### Added
 
 ### Fixed

package/lib/compile.js

@@ -45,13 +45,14 @@ const writeJsConfig = (path, logger) => {
  */
 const compileFromFile = async (inputFile, parameters) => {
     const paths = typeof inputFile === 'string' ? normalize(inputFile) : inputFile.map(f => normalize(f))
-    const csn = await cds.linked(await cds.load(paths, { docs: true, flavor: 'xtended' }))
-    return compileFromCSN(csn, parameters)
+    const xtended = await cds.linked(await cds.load(paths, { docs: true, flavor: 'xtended' }))
+    const inferred = await cds.linked(await cds.load(paths, { docs: true }))
+    return compileFromCSN({xtended, inferred}, parameters)
 }
 
 /**
  * Compiles a CSN object to Typescript types.
- * @param csn {CSN}
+ * @param {{xtended: CSN, inferred: CSN}} csn
  * @param parameters {CompileParameters} path to root directory for all generated files, min log level
  */
 const compileFromCSN = async (csn, parameters) => {
@@ -69,6 +70,5 @@ const compileFromCSN = async (csn, parameters) => {
 }
 
 module.exports = {
-    compileFromFile,
-    compileFromCSN,
+    compileFromFile
 }

package/lib/components/enum.js

@@ -0,0 +1,108 @@
+/**
+ * Prints an enum to a buffer. To be precise, it prints
+ * a constant object and a type which together form an artificial enum.
+ * CDS enums differ from TS enums as they can use bools as value (TS: only number and string)
+ * So we have to emulate enums by adding an object (name -> value mappings)
+ * and a type containing all disctinct values.
+ * We can get away with this as TS doesn't feature nominal typing, so the structure
+ * is all we care about.
+ * 
+ * @example
+ * ```cds
+ * type E: enum of String {
+ *   a = 'A';
+ *   b = 'B';
+ * }
+ * ```
+ * becomes
+ * ```ts
+ * const E = { a: 'A', b: 'B' }
+ * type E = 'A' | 'B'
+ * ```
+ *
+ * @param {Buffer} buffer Buffer to write into
+ * @param {string} name local name of the enum, i.e. the name under which it should be created in the .ts file
+ * @param {[string, string][]} kvs list of key-value pairs
+ */
+function printEnum(buffer, name, kvs, options = {}) {
+    const opts = {...{export: true}, ...options} 
+    buffer.add('// enum')
+    buffer.add(`${opts.export ? 'export ' : ''}const ${name} = {`)
+    buffer.indent()
+    const vals = new Set()
+    for (const [k, v] of kvs) {
+        buffer.add(`${k}: ${JSON.stringify(v)},`)
+        vals.add(JSON.stringify(v.val ?? v))  // in case of wrapped vals we need to unwrap here for the type
+    }
+    buffer.outdent()
+    buffer.add('} as const;')
+    buffer.add(`${opts.export ? 'export ' : ''}type ${name} = ${[...vals].join(' | ')}`)
+    buffer.add('')
+}
+
+// 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' ? `${value ?? key}` : value
+
+/**
+ * @param {{enum: {[key: name]: string}, type: string}} enumCsn
+ * @param {{unwrapVals: boolean}} options if `unwrapVals` is passed,
+ *  then the CSN structure `{val:x}` is flattened to just `x`.
+ *  Retaining `val` is closer to the actual CSN structure and should be used where we want
+ *  to mimic the runtime as closely as possible (anoymous enum types).
+ *  Stripping that additional wrapper would be more readable for users.
+ * @example
+ * ```ts 
+ * const csn = {enum: {x: {val: 42}, y: {val: -42}}}
+ * csnToEnum(csn) // -> [['x', 42], ['y': -42]]
+ * csnToEnum(csn, {unwrapVals: false}) // -> [['x', {val:42}], ['y': {val:-42}]]
+ * ```
+ */
+const csnToEnum = ({enum: enm, type}, options = {}) => {
+    options = {...{unwrapVals: true}, ...options}
+    return Object.entries(enm).map(([k, v]) => {
+        const val = enumVal(k, v.val, type)
+        return [k, options.unwrapVals ? val : { val }]
+    })
+}
+
+/**
+ * @param {string} entity
+ * @param {string} property
+ */
+const propertyToAnonymousEnumName = (entity, property) => `${entity}_${property}`
+
+/**
+ * A type is considered to be an inline enum, iff it has a `.enum` property
+ * _and_ its type is a CDS primitive, i.e. it is not contained in `cds.definitions`.
+ * If it is contained there, then it is a standard enum declaration that has its own name.
+ * 
+ * @param {{type: string}} element
+ * @param {object} csn
+ * @returns boolean
+ */
+const isInlineEnumType = (element, csn) => element.enum && !(element.type in csn.definitions)
+
+const stringifyEnumImplementation = (name, enm) => `module.exports.${name} = Object.fromEntries(Object.entries(${enm}).map(([k,v]) => [k,v.val]))`
+
+/**
+ * @param {string} name
+ * @param {string} fq
+ * @returns {string}
+ */
+const stringifyNamedEnum = (name, fq) => stringifyEnumImplementation(name, `cds.model.definitions['${fq}'].enum`)
+/**
+ * @param {string} name
+ * @param {string} fq
+ * @param {string} property
+ * @returns {string}
+ */
+const stringifyAnonymousEnum = (name, fq, property) => stringifyEnumImplementation(fq, `cds.model.definitions['${name}'].elements.${property}.enum`)
+
+module.exports = {
+    printEnum,
+    csnToEnum,
+    propertyToAnonymousEnumName,
+    isInlineEnumType,
+    stringifyNamedEnum,
+    stringifyAnonymousEnum
+}

package/lib/components/resolver.js

@@ -4,6 +4,7 @@ const util = require('../util')
 const { Buffer, SourceFile, Path, Library, baseDefinitions } = require("../file")
 const { deepRequire, createToManyAssociation, createToOneAssociation, createArrayOf, createCompositionOfMany, createCompositionOfOne } = require('./wrappers')
 const { StructuredInlineDeclarationResolver } = require("./inline")
+const { isInlineEnumType, propertyToInlineEnumName, propertyToAnonymousEnumName } = require('./enum')
 
 /** @typedef {{ cardinality?: { max?: '*' | number } }} EntityCSN */
 /** @typedef {{ definitions?: Object<string, EntityCSN> }} CSN */
@@ -63,7 +64,7 @@ const Builtins = {
 }
 
 class Resolver {
-    get csn() { return this.visitor.csn }
+    get csn() { return this.visitor.csn.inferred }
     
     /** @param {Visitor} visitor */
     constructor(visitor) {
@@ -106,6 +107,7 @@ class Resolver {
      * @returns {string} the entity name without leading namespace.
      */
     trimNamespace(p) {
+        // TODO: we might want to cache this
         // start on right side, go up while we have an entity at hand
         // we cant start on left side, as that clashes with undefined entities like "sap"
         const parts = p.split('.')
@@ -167,7 +169,7 @@ class Resolver {
             new StructuredInlineDeclarationResolver(this.visitor).printInlineType(undefined, { typeInfo }, into, '')
             typeName = into.join(' ')
             singular = typeName
-            plural = createArrayOf(typeName) //`Array<${typeName}>`
+            plural = createArrayOf(typeName)
         } else {
             // TODO: make sure the resolution still works. Currently, we only cut off the namespace!
             singular = util.singular4(typeInfo.csn)
@@ -310,10 +312,13 @@ class Resolver {
      * read from left to right which does not contain a kind 'context' or 'service'.
      * That is, if in the above example 'D' is a context and 'E' is a service,
      * the resulting namespace is 'a.b.c'.
-     * @param {string[]} pathParts the distinct parts of the namespace, i.e. ['a','b','c','D','E']
+     * @param {string[] | string} pathParts the distinct parts of the namespace, i.e. ['a','b','c','D','E'] or a single path interspersed with periods
      * @returns {string} the namespace's name, i.e. 'a.b.c'.
      */
     resolveNamespace(pathParts) {
+        if (typeof pathParts === 'string') {
+            pathParts = pathParts.split('.')
+        }
         let result
         while (result === undefined) {
             const path = pathParts.join('.')
@@ -350,14 +355,23 @@ class Resolver {
             isArray: false,
         }
 
-        // FIXME: switch case
         if (element?.type === undefined) {
             // "fallback" type "empty object". May be overriden via #resolveInlineDeclarationType
             // later on with an inline declaration
             result.type = '{}'
             result.isInlineDeclaration = true
         } else {
-            this.resolvePotentialReferenceType(element.type, result, file)
+            if (isInlineEnumType(element, this.csn)) {
+                // 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.
+                const cleanEntityName = util.singular4(element.parent, true)
+                const enumName = propertyToAnonymousEnumName(cleanEntityName, element.name)
+                result.type = enumName
+                result.plainName = enumName
+                result.isInlineDeclaration = true
+            } else {
+                this.resolvePotentialReferenceType(element.type, result, file)
+            }            
         }
 
         // objects and arrays

package/lib/csn.js

@@ -28,6 +28,7 @@ class DraftUnroller {
      */
     #setDraftable(entity, value) { 
         if (typeof entity === 'string') entity = this.#getDefinition(entity)
+        if (!entity) return  // inline definition -- not found in definitions
         entity[annotation] = value
         this.#draftable[entity.name] = value
         if (value) {
@@ -41,9 +42,13 @@ class DraftUnroller {
      * @param entity {object | string} - entity to look draftability up for.
      * @returns {boolean}
      */
-    #getDraftable(entity) { 
-        if (typeof entity === 'string') entity = this.#getDefinition(entity)
-        return this.#draftable[entity.name] ??= this.#propagateInheritance(entity) 
+    #getDraftable(entityOrName) {
+        const entity = (typeof entityOrName === 'string')
+            ? this.#getDefinition(entityOrName)
+            : entityOrName  
+        // assert(typeof entity !== 'string')
+        const name = entity?.name ?? entityOrName
+        return this.#draftable[name] ??= this.#propagateInheritance(entity) 
     }
 
     /**
@@ -59,8 +64,8 @@ class DraftUnroller {
      * @param entity {object} - entity to pull draftability from its parents.
      */
     #propagateInheritance(entity) {
-        const annotations = (entity.includes ?? []).map(parent => this.#getDraftable(parent))
-        annotations.push(entity[annotation])
+        const annotations = (entity?.includes ?? []).map(parent => this.#getDraftable(parent))
+        annotations.push(entity?.[annotation])
         this.#setDraftable(entity, annotations.filter(a => a !== undefined).at(-1) ?? false)
     }
 
@@ -127,7 +132,7 @@ class DraftUnroller {
  * (a) aspects via `A: B`, where `B` is draft enabled.
  * Note that when an entity extends two other entities of which one has drafts enabled and
  * one has not, then the one that is later in the list of mixins "wins":
- * @example sdasd
+ * @example
  * ```ts
  * ＠odata.draft.enabled true
  * entity T {}

package/lib/file.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs').promises
 const { readFileSync } = require('fs')
+const { printEnum, stringifyNamedEnum, stringifyAnonymousEnum, propertyToAnonymousEnumName } = require('./components/enum')
 const path = require('path')
 
 const AUTO_GEN_NOTE = "// This is an automatically generated file. Please do not change its contents manually!"
@@ -103,8 +104,10 @@ class SourceFile extends File {
         this.events = { buffer: new Buffer(), fqs: []} 
         /** @type {Buffer} */
         this.types = new Buffer()
-        /** @type {{ buffer: Buffer, fqs: {name: string, fq: string}[]}} */
+        /** @type {{ buffer: Buffer, fqs: {name: string, fq: string, property?: string}[]}} */
         this.enums = { buffer: new Buffer(), fqs: [] }
+        /** @type {{ buffer: Buffer }} */
+        this.inlineEnums = { buffer: new Buffer() }
         /** @type {Buffer} */
         this.classes = new Buffer()
         /** @type {{ buffer: Buffer, names: string[]}} */
@@ -119,6 +122,8 @@ class SourceFile extends File {
         this.typeNames = {}
         /** @type {[string, string, string][]} */
         this.inflections = []
+        /** @type {{ buffer: Buffer, names: string[]}} */
+        this.services = { buffer: new Buffer(), names: [] }
     }
 
     /**
@@ -127,18 +132,34 @@ class SourceFile extends File {
      * @returns {string} - the stringified lambda
      * @example
      * ```js
-     * stringifyLambda({parameters: [['p','T']]}  // (p: T) => any
-     * stringifyLambda({name: 'f', parameters: [['p','T']]}  // f: (p: T) => any
-     * stringifyLambda({name: 'f', parameters: [['p','T']], returns: 'number'}  // f: (p: T) => number
-     * stringifyLambda({name: 'f', parameters: [['p','T']], returns: 'number', initialiser: '_ => 42'}  // f: (p: T) => string = _ => 42
+     * // note: these samples are actually simplified! See below.
+     * stringifyLambda({parameters: [['p','T']]})  // f: { (p: T): any, ... }
+     * stringifyLambda({name: 'f', parameters: [['p','T']]})  // f: { (p: T) => any, ...  }
+     * stringifyLambda({name: 'f', parameters: [['p','T']], returns: 'number'})  // f: { (p: T) => number, ...  }
+     * stringifyLambda({name: 'f', parameters: [['p','T']], returns: 'number', initialiser: '_ => 42'})  // f: { (p: T): string = _ => 42, ...  }
+     * ```
+     * 
+     * The generated string will not be just the signature of the function. Instead, it will be an object offering a callable signature.
+     * On top of that, it will also expose a property `__parameters`, which is an object reflecting the functions parameters.
+     * The reason for this is that the CDS runtime actually treats the function parameters as a named object. This can not be rectified via
+     * type magic, as parameter names do not exist on type level. So we can not use these names to reuse them as object properties.
+     * Instead, we generate this utility object for the runtime to use:
      * 
+     * @example
+     * ```js
+     * stringifyLambda({name: 'f', parameters: [['p','T']], returns: 'number'})  // { (p: T): number, __parameters: { p: T } }
      * ```
      */
-    static stringifyLambda({name, parameters=[], returns='any', initialiser}) {
-        const signature = `(${parameters.map(([n, t]) => `${n}: ${t}`).join(', ')}) => ${returns}`
-        const prefix = name ? `${name}: `: ''
+    static stringifyLambda({name, parameters=[], returns='any', initialiser, isStatic=false}) {
+        const parameterTypes = parameters.map(([n, t]) => `${n}: ${t}`).join(', ')
+        const callableSignature = `(${parameterTypes}): ${returns}`
+        let prefix = name ? `${name}: `: ''
+        if (prefix && isStatic) {
+            prefix = `static ${prefix}`
+        }
         const suffix = initialiser ? ` = ${initialiser}` : ''
-        return prefix + signature + suffix
+        const lambda = `{ ${callableSignature}, __parameters: {${parameterTypes}}, __returns: ${returns} }`
+        return prefix + lambda + suffix
     }
 
     /**
@@ -202,31 +223,56 @@ class SourceFile extends File {
 
     /**
      * Adds an enum to this file.
-     * @param {string} fq fully qualified name of the enum
+     * @param {string} fq fully qualified name of the enum (entity name within CSN)
      * @param {string} name local name of the enum
      * @param {[string, string][]} kvs list of key-value pairs
+     * @param {string} [property] property to which the enum is attached. 
+     *  If given, the enum is considered to be an anonymous inline definition of an enum.
+     *  If not, it is considered to be regular, named enum.
      */
     addEnum(fq, name, kvs) {
-        // CDS differ from TS enums as they can use bools as value (TS: only number and string)
-        // So we have to emulate enums by adding an object (name -> value mappings)
-        // and a type containing all disctinct values.
-        // We can get away with this as TS doesn't feature nominal typing, so the structure
-        // is all we care about.
-        // FIXME: this really should be in visitor, as File should not contain logic of this kind
         this.enums.fqs.push({ name, fq })
-        const bu = this.enums.buffer
-        bu.add('// enum')
-        bu.add(`export const ${name} = {`)
-        bu.indent()
-        const vals = new Set()
-        for (const [k, v] of kvs) {
-            bu.add(`${k}: ${v},`)
-            vals.add(v)
-        }
-        bu.outdent()
-        bu.add('}')
-        bu.add(`export type ${name} = ${[...vals].join(' | ')}`)
-        bu.add('')
+        printEnum(this.enums.buffer, name, kvs)
+    }
+
+    /**
+     * Adds an anonymous enum to this file.
+     * @param {string} entityCleanName name of the entity the enum is attached to without namespace
+     * @param {string} entityFqName name of the entity the enum is attached to with namespace
+     * 
+     * @param {string} propertyName property to which the enum is attached. 
+     * @param {[string, string][]} kvs list of key-value pairs
+     *  If given, the enum is considered to be an anonymous inline definition of an enum.
+     *  If not, it is considered to be regular, named enum.
+     * 
+     * @example
+     * ```js
+     * addAnonymousEnum('Books.genre', 'Books', 'genre', [['horror','horror']])
+     * ```
+     * generates
+     * ```js
+     * // index.js
+     * module.exports.Books.genre = F(cds.model.definitions['Books'].elements.genre.enum)
+     * // F(...) is a function that maps a CSN enum to a more convenient style
+     * ```
+     * and also
+     * ```ts
+     * // index.ts
+     * const Books_genre = { horror: 'horror' }
+     * type Books_genre = 'horror'
+     * class Book {
+     *   static genre = Books_genre
+     *   genre: Books_genre
+     * }
+     * ```
+     */
+    addAnonymousEnum(entityCleanName, entityFqName, propertyName, kvs) {
+        this.enums.fqs.push({ 
+            name: entityFqName,
+            property: propertyName,
+            fq: `${entityCleanName}.${propertyName}`
+        })
+        printEnum(this.inlineEnums.buffer, propertyToAnonymousEnumName(entityCleanName, propertyName), kvs, {export: false})
     }
 
     /**
@@ -282,6 +328,19 @@ class SourceFile extends File {
         this.types.add(`export type ${clean} = ${rhs};`)
     }
 
+    /**
+     * Adds a service to the file.
+     * We consider each service its own distinct namespace and therefore expect
+     * at most one service per file.
+     * @param {string} fq the fully qualified name of the service
+     */
+    addService(fq) {
+        if (this.services.names.length) {
+            throw new Error(`trying to add more than one service to file ${this.path.asDirectory()}. Existing service is ${this.services.names[0]}, trying to add ${fq}`)
+        }
+        this.services.names.push(fq)
+    }
+
     /**
      * Writes all imports to a buffer, relative to the current file.
      * Creates a new buffer on each call, as concatenating import strings directly
@@ -311,12 +370,14 @@ class SourceFile extends File {
             this.getImports().join(),
             this.preamble.join(),
             this.types.join(),
-            this.enums.buffer.join(),
+            this.enums.buffer.join(), 
+            this.inlineEnums.buffer.join(), // needs to be before classes
             namespaces.join(),
             this.aspects.join(), // needs to be before classes
             this.classes.join(),
             this.events.buffer.join(),
             this.actions.buffer.join(),
+            this.services.buffer.join() // should be at the end
         ].filter(Boolean).join('\n')
     }
 
@@ -346,7 +407,11 @@ class SourceFile extends File {
             .concat(['// actions'])
             .concat(this.actions.names.map(name => `module.exports.${name} = '${name}'`))
             .concat(['// enums'])
-            .concat(this.enums.fqs.map(({fq, name}) => `module.exports.${name} = Object.fromEntries(Object.entries(cds.model.definitions['${fq}'].enum).map(([k,v]) => [k,v.val]))`))
+            .concat(this.enums.fqs.map(({name, fq, property}) => property 
+                ? stringifyAnonymousEnum(name, fq, property)
+                : stringifyNamedEnum(name, fq)))
+            // FIXME: move stringification of service into own module
+            .concat(this.services.names.map(name => `module.exports.default = { name: '${name}' }`))  // there should be only one
             .join('\n') + '\n'
     }
 }

package/lib/visitor.js

@@ -8,6 +8,7 @@ const { FlatInlineDeclarationResolver, StructuredInlineDeclarationResolver } = r
 const { Resolver } = require('./components/resolver')
 const { Logger } = require('./logging')
 const { docify } = require('./components/wrappers')
+const { csnToEnum, propertyToAnonymousEnumName, isInlineEnumType } = require('./components/enum')
 
  /** @typedef {import('./file').File} File */
  /** @typedef {{ entity: String }} Context */
@@ -56,11 +57,11 @@ class Visitor {
     }
 
     /**
-     * @param csn root CSN
+     * @param {{xtended: CSN, inferred: CSN}} csn root CSN
      * @param {VisitorOptions} options
      */
     constructor(csn, options = {}, logger = new Logger()) {
-        amendCSN(csn)
+        amendCSN(csn.xtended)
         this.options = { ...defaults, ...options }
         this.logger = logger
         this.csn = csn
@@ -96,8 +97,29 @@ class Visitor {
      * Visits all definitions within the CSN definitions.
      */
     visitDefinitions() {
-        for (const [name, entity] of Object.entries(this.csn.definitions)) {
-            this.visitEntity(name, entity)
+        for (const [name, entity] of Object.entries(this.csn.xtended.definitions)) {
+            if (entity._unresolved === true) {
+                this.logger.error(`Skipping unresolved entity: ${JSON.stringify(entity)}`)
+            } else {
+                this.visitEntity(name, entity)
+            }
+        }
+        // FIXME: optimise
+        // We are currently working with two flavours of CSN:
+        // xtended, as it is as close as possible to an OOP class hierarchy
+        // inferred, as it contains information missing in xtended
+        // This is less than optimal and has to be revisited at some point!
+        const handledKeys = new Set(Object.keys(this.csn.xtended.definitions))
+        // we are looking for autoexposed entities in services
+        const missing = Object.entries(this.csn.inferred.definitions).filter(([key]) => !key.endsWith('.texts') &&!handledKeys.has(key))
+        for (const [name, entity] of missing) {
+            // instead of using the definition from inferred CSN, we refer to the projected entity from xtended CSN instead.
+            // The latter contains the CSN fixes (propagated foreign keys, etc) and none of the localised fields we don't handle yet.
+            if (entity.projection) {
+                this.visitEntity(name, this.csn.xtended.definitions[entity.projection.from.ref[0]])
+            } else {
+                this.logger.error(`Expecting an autoexposed projection within a service. Skipping ${name}`)
+            }
         }
     }
 
@@ -112,7 +134,7 @@ class Visitor {
      * @param {Buffer} buffer the buffer to write the resulting definitions into
      * @param {string?} cleanName the clean name to use. If not passed, it is derived from the passed name instead.
      */
-    _aspectify(name, entity, buffer, cleanName = undefined) {
+    #aspectify(name, entity, buffer, cleanName = undefined) {
         const clean = cleanName ?? this.resolver.trimNamespace(name)
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
@@ -120,9 +142,7 @@ class Visitor {
         const identSingular = (name) => name
         const identAspect = (name) => `_${name}Aspect`
 
-        this.contexts.push({
-            entity: name,
-        })
+        this.contexts.push({ entity: name })
 
         // CLASS ASPECT
         buffer.add(`export function ${identAspect(clean)}<TBase extends new (...args: any[]) => object>(Base: TBase) {`)
@@ -130,6 +150,7 @@ class Visitor {
         buffer.add(`return class ${clean} extends Base {`)
         buffer.indent()
 
+        const enums = []
         for (const [ename, element] of Object.entries(entity.elements ?? {})) {
             this.visitElement(ename, element, file, buffer)
 
@@ -138,26 +159,42 @@ class Visitor {
                 // 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 ?? {})) {
+                for (const [kname, kelement] of Object.entries(this.csn.xtended.definitions[element.target]?.keys ?? {})) {
                     this.visitElement(`${ename}_${kname}`, kelement, file, buffer)
                 }
             }
-        }      
 
+            // store inline enums for later handling, as they have to go into one common "static elements" wrapper
+            if (isInlineEnumType(element, this.csn.xtended)) {
+                enums.push(element)
+            }
+        }
+
+        buffer.indent()
+        for (const e of enums) {
+            buffer.add(`static ${e.name} = ${propertyToAnonymousEnumName(clean, e.name)}`)
+            file.addAnonymousEnum(clean, name, e.name, csnToEnum(e, {unwrapVals: true}))
+        }
+        buffer.add('static actions: {')
+        buffer.indent()
         for (const [aname, action] of Object.entries(entity.actions ?? {})) {
             buffer.add(
                 SourceFile.stringifyLambda({
                     name: aname,
                     parameters: this.#stringifyFunctionParams(action.params, file),
-                    returns: action.returns ? this.resolver.resolveAndRequire(action.returns, file).typeName : 'any',
-                    initialiser: `undefined as unknown as this['${aname}']`
+                    returns: action.returns ? this.resolver.resolveAndRequire(action.returns, file).typeName : 'any'
+                    //initialiser: `undefined as unknown as typeof ${clean}.${aname}`,
                 })
             )
         }
         buffer.outdent()
-        buffer.add('};')
         buffer.outdent()
-        buffer.add('}')
+        buffer.add('}') // end of actions
+
+        buffer.outdent()
+        buffer.add('};') // end of generated class
+        buffer.outdent()
+        buffer.add('}')  // end of aspect
 
         // CLASS WITH ADDED ASPECTS
         file.addImport(baseDefinitions.path)
@@ -187,10 +224,12 @@ class Visitor {
     }
 
     #staticClassContents(clean, entity) {
-        return this.#isDraftEnabled(entity) ? [`static drafts: typeof ${clean}`] : [] 
+        return this.#isDraftEnabled(entity) ? [`static drafts: typeof ${clean}`] : []
     }
 
     #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 clean = this.resolver.trimNamespace(name)
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
@@ -206,7 +245,7 @@ class Visitor {
                 `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.`
             )
         }
-        if (singular in this.csn.definitions) {
+        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.`
             )
@@ -215,10 +254,9 @@ class Visitor {
         file.addClass(plural, name)
 
         const parent = this.resolver.resolveParent(entity.name)
-        const buffer =
-            parent && parent.kind === 'entity'
-                ? file.getSubNamespace(this.resolver.trimNamespace(parent.name))
-                : file.classes
+        const buffer = parent && parent.kind === 'entity'
+            ? file.getSubNamespace(this.resolver.trimNamespace(parent.name))
+            : file.classes
 
         // we can't just use "singular" here, as it may have the subnamespace removed:
         // "Books.text" is just "text" in "singular". Within the inflected exports we need
@@ -231,7 +269,7 @@ class Visitor {
             docify(entity.doc).forEach((d) => buffer.add(d))
         }
 
-        this._aspectify(name, entity, file.classes, singular)
+        this.#aspectify(name, entity, file.classes, singular)
 
         // PLURAL
         if (plural.includes('.')) {
@@ -241,6 +279,8 @@ 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')}}`)
+        buffer.add(overrideNameProperty(singular, entity.name))
+        buffer.add(overrideNameProperty(plural, entity.name))
         buffer.add('')
     }
 
@@ -289,13 +329,7 @@ class Visitor {
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
         if ('enum' in type) {
-            // in case of strings, wrap in quotes and fallback to key to make sure values are attached for every key
-            const val = (k,v) => type.type === 'cds.String' ? `"${v ?? k}"` : v
-            file.addEnum(
-                name,
-                clean,
-                Object.entries(type.enum).map(([k, v]) => [k, val(k, v.val)])
-            )
+            file.addEnum(name, clean, csnToEnum(type))
         } else {
             // alias
             file.addType(name, clean, this.resolver.resolveAndRequire(type, file).typeName)
@@ -313,7 +347,7 @@ class Visitor {
         // So we separate them into another buffer which is printed before the classes.
         file.addClass(clean, name)
         file.aspects.add(`// the following represents the CDS aspect '${clean}'`)
-        this._aspectify(name, aspect, file.aspects, clean)
+        this.#aspectify(name, aspect, file.aspects, clean)
     }
 
     #printEvent(name, event) {
@@ -336,6 +370,15 @@ class Visitor {
         buffer.add('}')
     }
 
+    #printService(name, service) {
+        this.logger.debug(`Printing service ${name}:\n${JSON.stringify(service, null, 2)}`)
+        const ns = this.resolver.resolveNamespace(name)
+        const file = this.getNamespaceFile(ns)
+        // service.name is clean of namespace
+        file.services.buffer.add(`export default { name: '${service.name}' }`)
+        file.addService(service.name)
+    }
+
     /**
      * Visits a single entity from the CSN's definition field.
      * Will call #printEntity or #printAction based on the entity's kind.
@@ -362,6 +405,9 @@ class Visitor {
             case 'event':
                 this.#printEvent(name, entity)
                 break
+            case 'service':
+                this.#printService(name, entity)
+                break
             default:
                 this.logger.error(`Unhandled entity kind '${entity.kind}'.`)
         }

package/package.json

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