@cap-js/cds-typer 0.30.0 → 0.32.0

package/CHANGELOG.md

@@ -1,12 +1,41 @@
-# Change Log
+# Changelog
 
 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.31.0 - TBD
+## [Unreleased]
 
-## Version 0.30.0 - 2024-12-02
+### Added
+### Changed
+### Deprecated
+### Removed
+### Fixed
+### Security
+
+## [0.32.0] - 2025-01-14
+
+### Added
+- dedicated classes for inline compositions
+- dedicated text-classes for entities with `localized` elements
+
+### Changed
+- prefixed builtin types like `Promise` and `Record` with `globalThis.`, to allow using names of builtin types for entities without collisions
+- bumped peer-dependency to `@cap-js/cds-types` to `>=0.9`
+### Deprecated
+### Removed
+### Fixed
+- referencing another entity's property of type `cds.String` in an enum will now properly quote the generated values
+### Security
+
+## [0.31.0] - 2024-12-16
+### Fixed
+- type-referencing a property that is a key no longer breaks the referring property
+- when targeting ESM, all imports within the generated types now add a `/index.js`-suffix to conform to modern module resolution mechanisms
+- leaving `target_module_type` at `'auto'` now properly acts on a detected `"type":"module"`
+
+### Added
+- cds aspects now generate a synthetic plural type too, to be used in `composition of many`
+
+## [0.30.0] - 2024-12-02
 
 ### Changed
 - [breaking] when running cds-typer in a CAP project, the default for the `outputDirectory` option will be `./@cds-models` instead of `./`. This default takes the lowest precedence after setting it in the project's `cds.env`, or explicitly as CLI argument.
@@ -14,20 +43,19 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Fixed
 - cds-typer no longer ignores the selected `outputDirectory`, which would also cause an issue during build
 
-
-## Version 0.29.0 - 2024-11-20
+## [0.29.0] - 2024-11-20
 ### Added
-- [breaking] cds-typer now tries to automatically detect whether it has to generate ESM or CommonJS in the emitted _index.js_ files. This behaviour can be overridden via the `--targetModuleType` option. _If you rely on these generated index.js files to be CJS despite your project being of ESM type, you need to manually tell cds-typer to generate CJS files!_ 
+- [breaking] cds-typer now tries to automatically detect whether it has to generate ESM or CommonJS in the emitted _index.js_ files. This behaviour can be overridden via the `--targetModuleType` option. _If you rely on these generated index.js files to be CJS despite your project being of ESM type, you need to manually tell cds-typer to generate CJS files!_
 
 ### Fixed
 - The static `.keys` property now properly reels in key types from inherited classes.
 
-## Version 0.28.1 - 2024-11-07
+## [0.28.1] - 2024-11-07
 ### Fixed
 - `cds build` no longer fails on Windows with an `EINVAL` error.
 - `cds build` also supports custom model paths in `tsconfig.json` that do not end with `/index.ts`.  This is the case for projects running with `tsx`.
 
-## Version 0.28.0 - 24-10-24
+## [0.28.0] - 24-10-24
 ### Added
 - Schema definition for `cds.typer` options in `package.json` and `.cdsrc-*.json` files
 - Added a static `elements` property to all entities, which allows access to the `LinkedDefinitions` instance of an entity's elements
@@ -40,7 +68,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Properly support mandatory (`not null`) action parameters with `array of` types
 - Static property `.drafts` is only create for entity classes that are actually draft enabled
 
-## Version 0.27.0 - 2024-10-02
+## [0.27.0] - 2024-10-02
 ### Changed
 - Any configuration variable (via CLI or `cds.env`) can now be passed in snake_case in addition to camelCase
 - Action parameters are now generated as optional by default, which is how the runtime treats them. Mandatory parameters have to be marked as `not null` in CDS/CDL, or `notNull` in CSN.
@@ -50,7 +78,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Fix a bug where cds-typer would produce redundant type declarations when the model contains an associations to another entity's property
 - Reintroduce default value `'.'` for `--outputDirectory`
 
-## Version 0.26.0 - 2024-09-11
+## [0.26.0] - 2024-09-11
 ### Added
 - Added a static `.keys` property in all entities. That property is dictionary which holds all properties as keys that are marked as `key` in CDS
 - Added a CLI option `--useEntitiesProxy`. When set to `true`, all entities are wrapped into `Proxy` objects during runtime, allowing top level imports of entity types.
@@ -63,8 +91,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Services now have their own export (named like the service itself). The current default export is not usable in some scenarios from CommonJS modules.
 - Enums and operation parameters can have doc comments
 
-
-## Version 0.25.0 - 2024-08-13
+## [0.25.0] - 2024-08-13
 ### Added
 - Declaring a type alias on an enum in cds now also exports it on value level in the resulting type
 
@@ -75,7 +102,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - All properties are now preceeded with the `declare` modifier to pass strict tsconfigs using `useDefineForClassFields` or `noImplicitOverride`
 - The static `actions` property of generated classes now includes the types from all inherited classes to also suggest actions defined in a base entity/aspect/type.
 
-## Version 0.24.0 - 2024-07-18
+## [0.24.0] - 2024-07-18
 ### Fixed
 - Suppressed an error that would incorrectly point out naming clashes when an entity was named in singular inflection in the model
 - CDS aspects now also generate a aspect-function in singular inflection, similar to how entities do
@@ -84,14 +111,13 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Aspects generate named classes again so that tooltips will show more meaningful provenance for properties
 - The TypeScript task for `cds build` no longer looks for tsconfig.json to determine if the project has TS nature and instead checks the dependencies in the project's package.json for an occurrence of `typescript`
 
-## Version 0.23.0 - 2024-07-04
+## [0.23.0] - 2024-07-04
 
 ### Fixed
 - Plurals no longer have `is_singular` attached in the resulting .js files
 - Properties are properly propagated beyond just one level of inheritance
 
-
-## Version 0.22.0 - 2024-06-20
+## [0.22.0] - 2024-06-20
 
 ### Fixed
 - Fixed a bug where keys would sometimes inconsistently become nullable
@@ -99,16 +125,15 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Changed
 - Logging now internally uses `cds.log` and pipes output into the `cds-typer` logger, which can be configured via `cds.env` in addition to explicitly passing a `--logLevel` parameter to CLI. Users now have to use the levels defined in [`cds.log.levels`](https://cap.cloud.sap/docs/node.js/cds-log#log-levels). The formerly valid levels `WARNING`, `CRITICAL`, and `NONE` are now deprecated and automatically mapped to valid levels for now.
 
-## Version 0.21.2 - 2024-06-06
+## [0.21.2] - 2024-06-06
 ### Fixed
 - The typescript build task will no longer attempt to run unless at least cds 8 is installed
 
-## Version 0.21.1 - 2024-06-03
+## [0.21.1] - 2024-06-03
 ### Fixed
 - Added missing _cds-plugin.js_ to exported files to properly enable calling `cds build --for typescript`
 
-
-## Version 0.21.0 - 2024-05-31
+## [0.21.0] - 2024-05-31
 ### Added
 - Added `IEEE754Compatible` flag which, when set to `true`, generates decimal fields as `(number | string)` instead of `number`. This flag will be removed in the long run
 - Added plugin to `cds build` TypeScript projects. Can be explicitly called using `cds build --for typescript`
@@ -122,15 +147,15 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Entities ending with an "s" are no longer incorrectly truncated within `extends`-clauses
 - Entity names prefixed with their own namespace (e.g. `Name.Name`, `Name.NameAttachments`) are not stripped of their name prefix
 
-## Version 0.20.2 - 2024-04-29
+## [0.20.2] - 2024-04-29
 ### Fixed
 - Referring to a property's type in a function/ action parameter no longer refers to the enclosing entity
 
-## Version 0.20.1 - 2024-04-24
+## [0.20.1] - 2024-04-24
 ### Fixed
 - Void actions no longer crash the type generation process
 
-## Version 0.20.0 - 2024-04-23
+## [0.20.0] - 2024-04-23
 ### Added
 - Types for actions and functions now expose a `.kind` property which holds the string `'function'` or `'action'` respectively
 - Added the `CdsDate`, `CdsDateTime`, `CdsTime`, `CdsTimestamp` types, which are each represented as a `string`.
@@ -146,32 +171,32 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Aspects are now consistently named and called in their singular form
 - Only detect inflection clash if singular and plural share the same namespace. This also no longer reports `sap.common` as erroneous during type creation
 
-## Version 0.19.0 - 2024-03-28
+## [0.19.0] - 2024-03-28
 ### Added
 - Support for `cds.Vector`, which will be represented as `string`
 
-## Version 0.18.2 - 2024-03-21
+## [0.18.2] - 2024-03-21
 ### Fixed
 - Resolving `@sap/cds` will now look in the CWD first to ensure a consistent use the same CDS version across different setups
 - Types of function parameters starting with `cds.` are not automatically considered builtin anymore and receive a more thorough check against an allow-list
 
 
-## Version 0.18.1 - 2024-03-13
+## [0.18.1] - 2024-03-13
 ### Fix
 - Remove faulty plural for CDS `type` definitions from the generated _index.js_ files
 
-## Version 0.18.0 - 2024-03-12
+## [0.18.0] - 2024-03-12
 ### Added
 - Improved support for projections, including projections on inline definitions, and on views, as well as support for explicit exclusion and selection of properties
 
 ### Changed
 - [breaking] CDS `type` definitions will not be inflected. Whatever inflection you define them in will be assumed treated as a singular form and will not receive a plural form anymore
 
-## Version 0.17.0 - 2024-03-05
+## [0.17.0] - 2024-03-05
 ### Fixed
 - Fixed a bug where refering to an externally defined enum via the `typeof` syntax would crash the type generation
 
-## Version 0.16.0 - 2024-02-01
+## [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
@@ -180,7 +205,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Fixed
 - Externally defined enums can now be used as parameter types in actions
 
-## Version 0.15.0 - 2023-12-21
+## [0.15.0] - 2023-12-21
 ### Added
 - Support for [scoped entities](https://cap.cloud.sap/docs/cds/cdl#scoped-names)
 - Support for [delimited identifiers](https://cap.cloud.sap/docs/cds/cdl#delimited-identifiers)
@@ -191,18 +216,18 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Arrays of inline enum values can now be used as action parameters too. But they will only be represented by their enclosing type for now, i.e. `string`, `number`, etc.
 - Foreign keys of projection entities are now propagated as well
 
-## Version 0.14.0 - 2023-12-13
+## [0.14.0] - 2023-12-13
 ### Added
 - Entities that are database views now also receive typings
 
-## Version 0.13.0 - 2023-12-06
+## [0.13.0] - 2023-12-06
 ### Changed
 - Enums are now generated ecplicitly in the respective _index.js_ files and don't have to extract their values from the model at runtime anymore
 
 ### Added
 - The `excluding` clause in projections now actually excludes the specified properties in the generated types
 
-## Version 0.12.0 - 2023-11-23
+## [0.12.0] - 2023-11-23
 
 ### Changed
 - Generate `cds.LargeBinary` as string, buffer, _or readable_ in the case of media content
@@ -213,7 +238,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Fixed
 - Now using names of enum values in generated _index.js_ files if no explicit value is present
 
-## Version 0.11.1 - 2023-10-12
+## [0.11.1] - 2023-10-12
 
 ### Changed
 
@@ -221,7 +246,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Fixed
 - Fixed how service names are exported as default export
 
-## Version 0.11.0 - 2023-10-10
+## [0.11.0] - 2023-10-10
 
 ### Changed
 
@@ -237,7 +262,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Removed
 - `compileFromCSN` is no longer part of the package's API
 
-## Version 0.10.0 - 2023-09-21
+## [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
@@ -246,7 +271,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### Fixed
 
-## Version 0.9.0 - 2023-09-08
+## [0.9.0] - 2023-09-08
 
 ### Changed
 
@@ -256,8 +281,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Fixed
 - Foreign keys are now propagated more than one level (think: `x_ID_ID_ID`)
 
-
-## Version 0.8.0 - 2023-09-05
+## [0.8.0] - 2023-09-05
 
 ### Changed
 
@@ -267,8 +291,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - 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
+## [0.7.0] - 2023-08-22
 
 ### Changed
 
@@ -277,7 +300,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Foreign keys are now present in the generated types in addition to the resolved property
 
 ### Fixed
-## Version 0.6.1 - 2023-08-10
+## [0.6.1] - 2023-08-10
 
 ### Changed
 
@@ -286,7 +309,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Fixed
 - Removed a warning about circular imports
 
-## Version 0.6.0 - 2023-08-07
+## [0.6.0] - 2023-08-07
 
 ### Added
 - Support for `event` syntax
@@ -296,7 +319,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Add leading underscore to appease `noUnusedParameters` in strict tsconfigs
 - No longer inflect `type` definitions when they are referenced within entities or other type definitions
 
-## Version 0.5.0 - 2023-07-25
+## [0.5.0] - 2023-07-25
 
 ### Changed
 - Facilitate strict property checks. Note: `checkJs: true` must be present in the project's _jsconfig.json_ or _tsconfig.json_ respectively for this feature to become effective
@@ -308,12 +331,11 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - Generate `string` type for date-related types in CDS definitions
 - Generate `Buffer | string` type for the CDS type `LargeBinary`
 
-
-## Version 0.4.0 - 2023-07-06
+## [0.4.0] - 2023-07-06
 ### Added
 - Support for enums when they are defined separately (not inline in the property type of an entity)
 
-## Version 0.3.0 - 2023-06-26
+## [0.3.0] - 2023-06-26
 ### Added
 - Support `function` definitions (apart from `action`s)
 ### Changed
@@ -322,25 +344,25 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 ### Fixed
 - Properly import CDS `type` definitions when they are referenced elsewhere
 
-## Version 0.2.5-beta.1 - 2023-06-13
+## [0.2.5-beta.1] - 2023-06-13
 
 ### Changed
 - Bump version
 
-## Version 0.2.4 - 2023-06-12
+## [0.2.4] - 2023-06-12
 - Enable use of annotated singular/ plural names in associations/ compositions
 - Rename package from `@sap/cds-dts-generator` to `@cap-js/cds-typer`
 
-## Version 0.2.3 - 2023-05-17
+## [0.2.3] - 2023-05-17
 - Add missing library files
 
-## Version 0.2.2 - 2023-05-17
+## [0.2.2] - 2023-05-17
 - Make class hierarchy flatter
 
-## Version 0.2.1 - 2023-05-16
+## [0.2.1] - 2023-05-16
 - Add missing files
 
-## Version 0.2.0 - 2023-05-15
+## [0.2.0] - 2023-05-15
 - use native Typescript AST in unit tests
 - add `propertiesOptional` flag
 - support flat, as well as nested inline declarations
@@ -351,9 +373,10 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - enable use of additional type libraries (HANA types available as first library)
 - provide proper JSDoc for all modules
 - export entity types for singular variants alongside plural types
-## Version 0.1.1 - 2023-01-26
+
+## [0.1.1] - 2023-01-26
 - add TL;DR section to README
 - allow multiple positional arguments
 
-## Version 0.1.0
+## [0.1.0] - 2023-01-01
 - initial code base

package/lib/components/basedefs.js

@@ -53,7 +53,7 @@ export type DraftOf<T> = { new(...args: any[]): DraftEntity<T> }
 export type DraftsOf<T> = typeof Array<DraftEntity<T>>
 
 export type DeepRequired<T> = { 
-    [K in keyof T]: DeepRequired<T[K]>
+    [K in keyof T]: DeepRequired<Unkey<T[K]>>
 } & Exclude<Required<T>, null>;
 
 const key = Symbol('key')  // to avoid .key showing up in IDE's auto-completion
@@ -63,6 +63,8 @@ export type KeysOf<T> = {
   [K in keyof T as NonNullable<T[K]> extends Key<unknown> ? K : never]-?: Key<{}>  // T[K] 
 }
 
+export type Unkey<T> = T extends Key<infer U> ? U : T
+
 /**
  * Dates and timestamps are strings during runtime, so cds-typer represents them as such.
  */

package/lib/components/enum.js

@@ -67,7 +67,7 @@ function printEnum(buffer, name, kvs, options = {}, doc=[]) {
  * Converts a CSN type describing an enum into a list of kv-pairs.
  * Values from CSN are unwrapped from their `.val` structure and
  * will fall back to the key if no value is provided.
- * @param {import('../typedefs').resolver.EnumCSN} enumCsn - the CSN type describing the enum
+ * @param {import('../typedefs').resolver.EnumCSN & { resolvedType?: string }} enumCsn - the CSN type describing the enum
  * @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
@@ -81,10 +81,10 @@ function printEnum(buffer, name, kvs, options = {}, doc=[]) {
  * csnToEnumPairs(csn, {unwrapVals: false}) // -> [['X', {val:'a'}], ['Y': {val:'b'}], ['Z':'Z']]
  * ```
  */
-const csnToEnumPairs = ({enum: enm, type}, options = {}) => {
+const csnToEnumPairs = ({enum: enm, type, resolvedType}, options = {}) => {
     const actualOptions = {...{unwrapVals: true}, ...options}
     return Object.entries(enm).map(([k, v]) => {
-        const val = enumVal(k, v.val, type)
+        const val = enumVal(k, v.val, resolvedType ?? type)  // if type is a ref, prefer the resolvedType to catch references to cds.Strings
         return [k, (actualOptions.unwrapVals ? val : { val })]
     })
 }

package/lib/components/typescript.js

@@ -1,3 +1,3 @@
 module.exports = {
-    empty: 'Record<never, never>'
+    empty: 'globalThis.Record<never, never>'
 }

package/lib/config.js

@@ -59,13 +59,15 @@ class Config {
         this.proxy = camelSnakeHybrid(this.values)
         if (this.proxy.targetModuleType === 'auto') {
             const type = getProjectTargetType(cds.root)
+            let detectedType = 'cjs'
             if (type) {
                 LOG.info(`automatically detected module type '${type}' in ${cds.root}`)
-                this.values.targetModuleType = type
+                detectedType = type
             } else {
                 LOG.warn(`target module type was set to 'auto', but could not detect module type in ${cds.root}. Falling back to cjs`)
-                this.values.targetModuleType = 'cjs'
             }
+            this.values.targetModuleType = detectedType
+            this.proxy.targetModuleType = detectedType
         }
     }
 

package/lib/csn.js

@@ -1,4 +1,5 @@
 const { LOG } = require('./logging')
+const { annotations } = require('./util')
 
 const DRAFT_ENABLED_ANNO = '@odata.draft.enabled'
 /** @type {string[]} */
@@ -292,6 +293,30 @@ function propagateForeignKeys(csn) {
     }
 }
 
+/**
+ * Clears "correct" singular/plural annotations from inferred model
+ * copies the ones from the xtended model.
+ *
+ * This is done to prevent potential duplicate class names because of annotation propagation.
+ * @param {{inferred: CSN, xtended: CSN}} csn - CSN models
+ */
+function propagateInflectionAnnotations(csn) {
+    const singularAnno = annotations.singular[0]
+    const pluralAnno = annotations.plural[0]
+    for (const [name, def] of Object.entries(csn.inferred.definitions)) {
+        const xtendedDef = csn.xtended.definitions[name]
+        // we keep the annotations from definition specific to the inferred model (e.g. inline compositions)
+        if (!xtendedDef) continue
+
+        // clear annotations from inferred definition
+        if (Object.hasOwn(def, singularAnno)) delete def[singularAnno]
+        if (Object.hasOwn(def, pluralAnno)) delete def[pluralAnno]
+        // transfer annotation from xtended if existing
+        if (Object.hasOwn(xtendedDef, singularAnno)) def[singularAnno] = xtendedDef[singularAnno]
+        if (Object.hasOwn(xtendedDef, pluralAnno)) def[pluralAnno] = xtendedDef[pluralAnno]
+    }
+}
+
 /**
  * @param {EntityCSN} entity - the entity
  */
@@ -311,6 +336,25 @@ const getProjectionAliases = entity => {
     return { aliases, all }
 }
 
+/**
+ * Heuristic way of looking up a reference type.
+ * We currently only support up to two segments,
+ * the first referring to the entity, a possible second
+ * referring to an element of the entity.
+ * @param {CSN} csn - CSN
+ * @param {string[]} ref - reference
+ * @returns {EntityCSN}
+ */
+function lookUpRefType (csn, ref) {
+    if (ref.length > 2) throw new Error(`Unsupported reference type ${ref.join('.')} with ${ref.length} segments. Please report this error.`)
+    /** @type {EntityCSN | undefined} */
+    let result = csn.definitions[ref[0]]  // entity
+    if (ref.length === 1) return result
+    result = result?.elements?.[ref[1]]  // property
+    if (!result) throw new Error(`Failed to look up reference type ${ref.join('.')}`)
+    return result
+}
+
 module.exports = {
     collectDraftEnabledEntities,
     isView,
@@ -326,5 +370,7 @@ module.exports = {
     getProjectionAliases,
     getViewTarget,
     propagateForeignKeys,
-    isCsnAny
+    propagateInflectionAnnotations,
+    isCsnAny,
+    lookUpRefType
 }

package/lib/file.js

@@ -257,6 +257,7 @@ class SourceFile extends File {
         if (!(name in this.namespaces)) {
             const buffer = new Buffer()
             buffer.closed = false
+            buffer.namespace = name
             buffer.add(`export namespace ${name} {`)
             buffer.indent()
             this.namespaces[name] = buffer
@@ -286,6 +287,8 @@ class SourceFile extends File {
      * @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
+     * @param {Buffer} [buffer] - if buffer is of subnamespace the enum will be added there,
+     *                            otherwise to the inline enums of the file
      * @param {string[]} doc - the enum docs
      *  If given, the enum is considered to be an inline definition of an enum.
      *  If not, it is considered to be regular, named enum.
@@ -310,16 +313,32 @@ class SourceFile extends File {
      * }
      * ```
      */
-    addInlineEnum(entityCleanName, entityFqName, propertyName, kvs, doc=[]) {
+    addInlineEnum(entityCleanName, entityFqName, propertyName, kvs, buffer, doc=[]) {
+        const namespacedEntity = [buffer?.namespace, entityCleanName].filter(Boolean).join('.')
         this.enums.data.push({
-            name: `${entityCleanName}.${propertyName}`,
+            name: `${namespacedEntity}.${propertyName}`,
             property: propertyName,
             kvs,
-            fq: `${entityCleanName}.${propertyName}`
+            fq: `${namespacedEntity}.${propertyName}`
         })
-        const entityProxy = this.entityProxies[entityCleanName] ?? (this.entityProxies[entityCleanName] = [])
+        const entityProxy = this.entityProxies[namespacedEntity] ?? (this.entityProxies[namespacedEntity] = [])
         entityProxy.push(propertyName)
-        printEnum(this.inlineEnums.buffer, propertyToInlineEnumName(entityCleanName, propertyName), kvs, {export: false}, doc)
+
+        // REVISIT: find a better way to do this???
+        const printEnumToBuffer = (/** @type {Buffer} */buffer) => printEnum(buffer, propertyToInlineEnumName(entityCleanName, propertyName), kvs, {export: false}, doc)
+
+        if (buffer?.namespace) {
+            const tempBuffer = new Buffer()
+            // we want to put the enums on class level
+            tempBuffer.indent()
+            printEnumToBuffer(tempBuffer)
+
+            // we want to write the enums at the beginning of the namespace
+            const [first,...rest] = buffer.parts
+            buffer.parts = [first, ...tempBuffer.parts, ...rest]
+        } else {
+            printEnumToBuffer(this.inlineEnums.buffer)
+        }
     }
 
     /**
@@ -405,9 +424,13 @@ class SourceFile extends File {
             // currently only needed to extend cds.Service and would trigger unused-variable-errors in strict configs
             buffer.add('import cds from \'@sap/cds\'') // TODO should go to visitor#printService, but can't express this as Path
         }
+        const file = configuration.targetModuleType === 'esm'
+            ? '/index.js'
+            : ''
         for (const imp of Object.values(this.imports)) {
             if (!imp.isCwd(this.path.asDirectory())) {
-                buffer.add(`import * as ${imp.asIdentifier()} from '${imp.asDirectory({relative: this.path.asDirectory()})}';`)
+                const from = imp.asDirectory({relative: this.path.asDirectory()}) + file
+                buffer.add(`import * as ${imp.asIdentifier()} from '${from}';`)
             }
         }
         buffer.blankLine()
@@ -486,12 +509,15 @@ class SourceFile extends File {
 
             return {
                 singularRhs: `createEntityProxy(['${namespace}', '${original}'], { target: { is_singular: true }${customPropsStr} })`,
-                pluralRhs: `createEntityProxy(['${namespace}', '${original}'])`,
+                pluralRhs: `createEntityProxy(['${namespace}', '${original}'], { target: { is_singular: false }})`,
             }
         } else {
+            // standard entity: csn.Books
+            // inline entity: csn['Books.texts']
+            const csnAccess = original.includes('.') ? `csn['${original}']` : `csn.${original}`
             return {
-                singularRhs: `{ is_singular: true, __proto__: csn.${original} }`,
-                pluralRhs: `csn.${original}`
+                singularRhs: `{ is_singular: true, __proto__: ${csnAccess} }`,
+                pluralRhs: csnAccess
             }
         }
     }
@@ -585,6 +611,11 @@ class Buffer {
          * @type {boolean}
          */
         this.closed = false
+        /**
+         * Required for inline enums of inline compositions or text entities
+         * @type {string | undefined}
+         */
+        this.namespace = undefined
     }
 
     /**

package/lib/printers/javascript.js

@@ -1,3 +1,11 @@
+/**
+ * Forcefully overrides the .name property of a class.
+ * See: https://github.com/microsoft/TypeScript/issues/442
+ * @param {string} clazz - the class to override the name property for
+ * @param {string} content - the content to set the name property to
+ */
+const overrideNameProperty = (clazz, content) => `Object.defineProperty(${clazz}, 'name', { value: '${content}' })`
+
 class JavaScriptPrinter {
     /**
      * @param {string} text - comment text
@@ -76,12 +84,14 @@ class ESMPrinter extends JavaScriptPrinter {
 
     /** @type {JavaScriptPrinter['printDeconstructedImport']} */
     printDeconstructedImport (imports, from) {
-        return `import { ${imports.join(', ')} } from '${from}'`
+        return `import { ${imports.join(', ')} } from '${from}/index.js'`
     }
 
     /** @type {JavaScriptPrinter['printExport']} */
     printExport (name, value) {
-        return `export const ${name} = ${value}`
+        return name.includes('.')
+            ? `${name} = ${value}`
+            : `export const ${name} = ${value}`
     }
 
     /** @type {JavaScriptPrinter['printDefaultExport']} */
@@ -127,5 +137,6 @@ class CJSPrinter extends JavaScriptPrinter {
 
 module.exports = {
     CJSPrinter,
-    ESMPrinter
+    ESMPrinter,
+    overrideNameProperty
 }

package/lib/printers/wrappers.js

@@ -103,7 +103,7 @@ const createIntersectionOf = (...types) => types.join(' & ')
  * createPromiseOf('string') // -> 'Promise<string>'
  * ```
  */
-const createPromiseOf = t => `Promise<${t}>`
+const createPromiseOf = t => `globalThis.Promise<${t}>`
 
 /**
  * Wraps type into a deep require (removes all posibilities of undefined recursively).
@@ -113,6 +113,14 @@ const createPromiseOf = t => `Promise<${t}>`
  */
 const deepRequire = (t, lookup = '') => `${base}.DeepRequired<${t}>${lookup}`
 
+/**
+ * Wraps a type into an unkey type (removes they Key<> type).
+ * This is needed for type references, where Foo:id should result in `typeof id`, not `Key<typeof id>`.
+ * @param {string} t - the type to wrap.
+ * @returns {string}
+ */
+const unkey = t => `${base}.Unkey<${t}>`
+
 /**
  * Puts a passed string in docstring format.
  * @param {string | undefined} doc - raw string to docify. May contain linebreaks.
@@ -150,5 +158,6 @@ module.exports = {
     createCompositionOfMany,
     deepRequire,
     docify,
-    stringIdent
+    stringIdent,
+    unkey
 }

package/lib/resolution/entity.js

@@ -61,6 +61,22 @@ class EntityInfo {
     /** @type {import('../typedefs').resolver.EntityCSN | undefined} */
     #csn
 
+    /** @type {Set<string> | undefined} */
+    #inheritedElements
+
+    /** @returns set of inherited elements (e.g. ID of aspect cuid) */
+    get inheritedElements() {
+        if (this.#inheritedElements) return this.#inheritedElements
+        this.#inheritedElements = new Set()
+        for (const parentName of this.csn.includes ?? []) {
+            const parent = this.#repository.getByFq(parentName)
+            for (const element of Object.keys(parent?.csn?.elements ?? {})) {
+                this.#inheritedElements.add(element)
+            }
+        }
+        return this.#inheritedElements
+    }
+
     /** @returns the **inferred** csn for this entity. */
     get csn () {
         return this.#csn ??= this.#resolver.csn.definitions[this.fullyQualifiedName]
@@ -189,6 +205,8 @@ function asIdentifier ({info, wrapper = undefined, relative = undefined}) {
         : `${info.namespace.asIdentifier()}.${wrapped}`
 }
 
+/** @typedef {EntityInfo} Info */
+
 module.exports = {
     EntityRepository,
     asIdentifier

package/lib/resolution/resolver.js

@@ -24,7 +24,7 @@ const { configuration } = require('../config')
 /** @typedef {{typeName: string, typeInfo: TypeResolveInfo & { inflection: Inflection }}} ResolveAndRequireInfo */
 
 class Resolver {
-    get csn() { return this.visitor.csn.inferred }
+    get csn() { return this.visitor.csn }
 
     /** @param {Visitor} visitor - the visitor */
     constructor(visitor) {
@@ -165,11 +165,13 @@ class Resolver {
          */
         const isPropertyOf = (property, entity) => property && Object.hasOwn(entity?.elements ?? {}, property)
 
-        const defs = this.visitor.csn.inferred.definitions
+        const defs = this.visitor.csn.definitions
+
+        // check if name is already an entity, then we do not have a property access, but a nested entity
+        if (defs[p]?.kind === 'entity') return []
+
         // assume parts to contain [Namespace, Service, Entity1, Entity2, Entity3, property1, property2]
-        /** @type {string} */
-        // @ts-expect-error - nope, we know there is at least one element
-        let qualifier = parts.shift()
+        let qualifier = /** @type {string} */ (parts.shift())
         // find first entity from left (Entity1)
         while ((!defs[qualifier] || !isEntity(defs[qualifier])) && parts.length) {
             qualifier += `.${parts.shift()}`
@@ -240,6 +242,8 @@ class Resolver {
         } else {
             // TODO: make sure the resolution still works. Currently, we only cut off the namespace!
             plural = util.getPluralAnnotation(typeInfo.csn) ?? typeInfo.plainName
+            // remove leading entity name
+            if (plural.includes('.')) plural = last(plural)
             singular = util.getSingularAnnotation(typeInfo.csn) ?? util.singular4(typeInfo.csn, true) // util.singular4(typeInfo.csn, true)  // can not use `plural` to honor possible @singular annotation
 
             // don't slice off namespace if it isn't part of the inflected name.
@@ -311,18 +315,6 @@ class Resolver {
                 } else {
                     let { singular, plural } = targetTypeInfo.typeInfo.inflection
 
-                    // FIXME: super hack!!
-                    // Inflection currently does not retain the scope of the entity.
-                    // But we can't just fix it in inflection(...), as that would break several other things
-                    // So we bandaid-fix it back here, as it is the least intrusive place -- but this should get fixed asap!
-                    if (target.type) {
-                        const untangled = this.visitor.entityRepository.getByFqOrThrow(target.type)
-                        const scope = untangled.scope.join('.')
-                        if (scope && !singular.startsWith(scope)) {
-                            singular = `${scope}.${singular}`
-                        }
-                    }
-
                     typeName = cardinality > 1
                         ? toMany(plural)
                         : toOne(this.visitor.isSelfReference(target) ? 'this' : singular)
@@ -370,8 +362,14 @@ class Resolver {
         // handle typeof (unless it has already been handled above)
         const target = element.target?.name ?? element.type?.ref?.join('.') ?? element.type
         if (target && !typeInfo.isDeepRequire) {
-            const { propertyAccess } =  this.visitor.entityRepository.getByFq(target) ?? {}
-            if (propertyAccess?.length) {
+            const { propertyAccess, scope } =  this.visitor.entityRepository.getByFq(target) ?? {}
+            if (scope?.length) {
+                // update inflections with proper prefix, e.g. Books.text, Books.texts
+                typeInfo.inflection = {
+                    singular: [...scope, typeInfo.inflection?.singular].join('.'),
+                    plural: [...scope, typeInfo.inflection?.plural].join('.')
+                }
+            } else if (propertyAccess?.length) {
                 const element = target.slice(0, -propertyAccess.join('.').length - 1)
                 const access = this.visitor.inlineDeclarationResolver.getTypeLookup(propertyAccess)
                 // singular, as we have to access the property of the entity
@@ -452,6 +450,7 @@ class Resolver {
 
         const cardinality = getMaxCardinality(element)
 
+        /** @type {TypeResolveInfo} */
         const result = {
             isBuiltin: false, // will be rectified in the corresponding handlers, if needed
             isInlineDeclaration: false,
@@ -569,7 +568,7 @@ class Resolver {
      * @returns @see resolveType
      */
     resolveTypeName(t, into) {
-        const result = into ?? {}
+        const result = into ?? /** @type {TypeResolveInfo} */({})
         const path = t.split('.')
         const builtin = this.builtinResolver.resolveBuiltin(path)
         if (builtin === undefined) {

package/lib/typedefs.d.ts

@@ -13,7 +13,7 @@ export module resolver {
         compositions?: { target: string }[]
         doc?: string,
         elements?: { [key: string]: EntityCSN }
-        key?: string // custom!!
+        key?: boolean // custom!!
         keys?: { [key:string]: any }
         kind: string,
         includes?: string[]
@@ -25,6 +25,8 @@ export module resolver {
         target?: string,
         type: string | ref,
         name: string,
+        '@singular'?: string,
+        '@plural'?: string,
         '@odata.draft.enabled'?: boolean // custom!
         _unresolved?: boolean
         isRefNotNull?: boolean // custom!
@@ -46,7 +48,8 @@ export module resolver {
 
 
     export type EnumCSN = EntityCSN & {
-        enum: {[key:name]: string}
+        enum: {[key:name]: string},
+        resolvedType?: string  // custom property! When .type points to a ref, the visitor will resolve the ref into this property
     }
 
     export type CSN = {

package/lib/util.js

@@ -15,10 +15,10 @@ if (process.version.startsWith('v14')) {
 
 const last = /\w+$/
 
-const annotations = {
+const annotations = /** @type {const} */ ({
     singular: ['@singular'],
     plural: ['@plural'],
-}
+})
 
 /**
  * Converts a camelCase string to snake_case.

package/lib/visitor.js

@@ -1,8 +1,6 @@
 'use strict'
 
-const util = require('./util')
-
-const { isView, isUnresolved, propagateForeignKeys, collectDraftEnabledEntities, isDraftEnabled, isType, isProjection, getMaxCardinality, isViewOrProjection, isEnum, isEntity } = require('./csn')
+const { propagateForeignKeys, propagateInflectionAnnotations, collectDraftEnabledEntities, isDraftEnabled, isType, getMaxCardinality, isViewOrProjection, isEnum, isEntity, lookUpRefType } = require('./csn')
 // eslint-disable-next-line no-unused-vars
 const { SourceFile, FileRepository, Buffer, Path } = require('./file')
 const { FlatInlineDeclarationResolver, StructuredInlineDeclarationResolver } = require('./components/inline')
@@ -18,6 +16,7 @@ const { last } = require('./components/identifier')
 const { getPropertyModifiers } = require('./components/property')
 const { configuration } = require('./config')
 const { createMember } = require('./components/class')
+const { overrideNameProperty } = require('./printers/javascript')
 
 /** @typedef {import('./file').File} File */
 /** @typedef {import('./typedefs').visitor.Context} Context */
@@ -27,6 +26,7 @@ const { createMember } = require('./components/class')
 /** @typedef {import('./typedefs').resolver.EntityCSN} EntityCSN */
 /** @typedef {import('./typedefs').resolver.EnumCSN} EnumCSN */
 
+
 class Visitor {
     /**
      * Gathers all files that are supposed to be written to
@@ -42,11 +42,12 @@ class Visitor {
      * @param {{xtended: CSN, inferred: CSN}} csn - root CSN
      */
     constructor(csn) {
-        propagateForeignKeys(csn.xtended)
         propagateForeignKeys(csn.inferred)
-        // has to be executed on the inferred model as autoexposed entities are not included in the xtended csn
+        propagateInflectionAnnotations(csn)
         collectDraftEnabledEntities(csn.inferred)
-        this.csn = csn
+
+        // xtendend csn not required after this point -> continue with inferred
+        this.csn = csn.inferred
 
         /** @type {Context[]} **/
         this.contexts = []
@@ -72,41 +73,8 @@ class Visitor {
      * Visits all definitions within the CSN definitions.
      */
     visitDefinitions() {
-        for (const [name, entity] of Object.entries(this.csn.xtended.definitions)) {
-            if (isView(entity)) {
-                this.visitEntity(name, this.csn.inferred.definitions[name])
-            } else if (isProjection(entity) || !isUnresolved(entity)) {
-                this.visitEntity(name, entity)
-            } else {
-                LOG.warn(`Skipping unresolved entity: ${name}`)
-            }
-        }
-        // 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) {
-                const targetName = entity.projection.from.ref[0]
-                // FIXME: references to types of entity properties may be missing from xtendend flavour (see #103)
-                // this should be revisted once we settle on a single flavour.
-                const target = this.csn.xtended.definitions[targetName] ?? this.csn.inferred.definitions[targetName]
-                if (target.kind !== 'type') {
-                    // skip if the target is a property, like in:
-                    // books: Association to many Author.books ...
-                    // as this would result in a type definition that
-                    // name-clashes with the actual declaration of Author
-                    this.visitEntity(name, target)
-                }
-            } else {
-                LOG.error(`Expecting an autoexposed projection within a service. Skipping ${name}`)
-            }
+        for (const [name, entity] of Object.entries(this.csn.definitions)) {
+            this.visitEntity(name, entity)
         }
     }
 
@@ -117,15 +85,8 @@ class Visitor {
      * @returns {[string, object][]} array of key name and key element pairs
      */
     #keys(fq) {
-        // FIXME: this is actually pretty bad, as not only have to propagate keys through
-        // both flavours of CSN (see constructor), but we are now also collecting them from
-        // both flavours and deduplicating them.
-        // xtended contains keys that have been inherited from parents
-        // inferred contains keys from queried entities (thing `entity Foo as select from Bar`, where Bar has keys)
-        // So we currently need them both.
         return Object.entries({
-            ...this.csn.inferred.definitions[fq]?.keys ?? {},
-            ...this.csn.xtended.definitions[fq]?.keys ?? {}
+            ...this.csn.definitions[fq]?.keys ?? {}
         })
     }
 
@@ -231,7 +192,7 @@ class Visitor {
         // FIXME: replace with resolution/entity::asIdentifier
         const toLocalIdent = ({ns, clean, fq}) => {
             // types are not inflected, so don't change those to singular
-            const csn = this.csn.inferred.definitions[fq]
+            const csn = this.csn.definitions[fq]
             const ident = isType(csn)
                 ? clean
                 : this.resolver.inflect({csn, plainName: clean}).singular
@@ -261,6 +222,7 @@ class Visitor {
             .reverse() // reverse so that own aspect A is applied before extensions B,C: B(C(A(Entity)))
             .reduce((wrapped, ancestor) => `${asIdentifier({info: ancestor, wrapper: name => `_${name}Aspect`, relative: file.path})}(${wrapped})`, 'Base')
 
+        const inheritedElements = !isViewOrProjection(entity) ? info.inheritedElements : null
         this.contexts.push({ entity: fq })
 
         // CLASS ASPECT
@@ -272,10 +234,7 @@ class Visitor {
                 const resolverOptions = { forceInlineStructs: isEntity(entity) && configuration.inlineDeclarations === 'flat'}
 
                 for (let [ename, element] of Object.entries(entity.elements ?? [])) {
-                    if (element.target && /\.texts?/.test(element.target)) {
-                        LOG.warn(`referring to .texts property in ${fq}. This is currently not supported and will be ignored.`)
-                        continue
-                    }
+                    if (inheritedElements?.has(ename)) continue
                     this.visitElement({name: ename, element, file, buffer, resolverOptions})
 
                     // make foreign keys explicit
@@ -290,7 +249,8 @@ class Visitor {
                                     LOG.error(`Attempting to generate a foreign key reference called '${foreignKey}' in type definition for entity ${fq}. But a property of that name is already defined explicitly. Consider renaming that property.`)
                                 } else {
                                     const kelement = Object.assign(Object.create(originalKeyElement), {
-                                        isRefNotNull: !!element.notNull || !!element.key
+                                        isRefNotNull: !!element.notNull || !!element.key,
+                                        key: element.key
                                     })
                                     this.visitElement({name: foreignKey, element: kelement, file, buffer, resolverOptions})
                                 }
@@ -299,7 +259,7 @@ class Visitor {
                     }
 
                     // store inline enums for later handling, as they have to go into one common "static elements" wrapper
-                    if (isInlineEnumType(element, this.csn.xtended)) {
+                    if (isInlineEnumType(element, this.csn)) {
                         enums.push(element)
                     }
                 }
@@ -312,7 +272,10 @@ class Visitor {
                         initialiser: propertyToInlineEnumName(clean, e.name),
                         isStatic: true,
                     }))
-                    file.addInlineEnum(clean, fq, e.name, csnToEnumPairs(e, {unwrapVals: true}), eDoc)
+                    if (typeof e?.type !== 'string' && e?.type?.ref) {
+                        e.resolvedType = /** @type {string} */(lookUpRefType(this.csn, e.type.ref)?.type)
+                    }
+                    file.addInlineEnum(clean, fq, e.name, csnToEnumPairs(e, {unwrapVals: true}), buffer, eDoc)
                 }
 
                 if ('kind' in entity) {
@@ -354,13 +317,8 @@ class Visitor {
      * @param {EntityCSN} entity - the entity to print
      */
     #printEntity(fq, entity) {
-        // static .name has to be defined more forcefully: https://github.com/microsoft/TypeScript/issues/442
-        /**
-         * @param {string} clazz - the class to override the name property for
-         * @param {string} content - the content to set the name property to
-         */
-        const overrideNameProperty = (clazz, content) => `Object.defineProperty(${clazz}, 'name', { value: '${content}' })`
-        const { namespace: ns, entityName: clean, inflection } = this.entityRepository.getByFqOrThrow(fq)
+        const info = this.entityRepository.getByFqOrThrow(fq)
+        const { namespace: ns, entityName: clean, inflection, scope } = info
         const file = this.fileRepository.getNamespaceFile(ns)
         let { singular, plural } = inflection
 
@@ -376,7 +334,7 @@ class Visitor {
         // as types are not inflected, their singular will always clash and there is also no plural for them anyway -> skip
         // if the user defined their entities in singular form we would also have a false positive here -> skip
         const namespacedSingular = `${ns.asNamespace()}.${singular}`
-        if (!isType(entity) && namespacedSingular !== fq && namespacedSingular in this.csn.xtended.definitions) {
+        if (!isType(entity) && namespacedSingular !== fq && namespacedSingular in this.csn.definitions) {
             LOG.error(
                 `Derived singular '${singular}' for your entity '${fq}', 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.`
             )
@@ -389,43 +347,48 @@ class Visitor {
             ? 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
-        // 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.
-        // edge case: @singular annotation present. singular4 will take care of that.
-        file.addInflection(util.singular4(entity, true), plural, clean)
-
-        // in case of projections `entity` is empty -> retrieve from inferred csn where the actual properties are rolled out
-        const target = isProjection(entity) || isView(entity)
-            ? this.csn.inferred.definitions[fq]
-            : entity
+        if (scope?.length > 0) {
+            /** @param {string} n - name of entity */
+            const scoped = n => [...scope, n].join('.')
+            file.addInflection(scoped(singular), scoped(plural), scoped(clean))
+        } else {
+            file.addInflection(singular, plural, clean)
+        }
 
-        this.#aspectify(fq, target, buffer, { cleanName: singular })
+        this.#aspectify(fq, entity, buffer, { cleanName: singular })
 
         buffer.add(overrideNameProperty(singular, entity.name))
         buffer.add(`Object.defineProperty(${singular}, 'is_singular', { value: true })`)
 
         // PLURAL
-
         // types do not receive a plural
         if (!isType(entity)) {
-            if (plural.includes('.')) {
-                // Foo.text -> namespace Foo { class text { ... }}
-                plural = last(plural)
-            }
-            // 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.
-            const additionalProperties = this.#staticClassContents(fq, singular, true)
-            additionalProperties.push('$count?: number')
-            buffer.add(docify(entity.doc))
-            buffer.add(`export class ${plural} extends Array<${singular}> {${additionalProperties.join('\n')}}`)
-            buffer.add(overrideNameProperty(plural, entity.name))
+            this.#printPlural(info, buffer)
         }
         buffer.blankLine()
     }
 
+    /**
+     * @param {import('./resolution/entity').Info} info - the entity info
+     * @param {import('./file').Buffer} buffer - buffer to write the plural into
+     */
+    #printPlural(info, buffer) {
+        const { fullyQualifiedName: fq, csn: entity } = info
+        let { singular, plural } = info.inflection
+
+        if (plural.includes('.')) {
+            // Foo.text -> namespace Foo { class text { ... }}
+            plural = last(plural)
+        }
+        // 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.
+        const additionalProperties = this.#staticClassContents(fq, singular, true)
+        additionalProperties.push('$count?: number')
+        buffer.add(docify(entity.doc))
+        buffer.add(`export class ${plural} extends Array<${singular}> {${additionalProperties.join('\n')}}`)
+        buffer.add(overrideNameProperty(plural, entity.name))
+    }
+
     /**
      * 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.
@@ -509,7 +472,7 @@ class Visitor {
         if (isEnum(type) && !isReferenceType(type) && this.resolver.builtinResolver.resolveBuiltin(type.type)) {
             file.addEnum(fq, entityName, csnToEnumPairs(type), docify(type.doc))
         } else {
-            const isEnumReference = typeof type.type === 'string' && isEnum(this.csn.inferred.definitions[type?.type])
+            const isEnumReference = typeof type.type === 'string' && isEnum(this.csn.definitions[type?.type])
             // alias
             file.addType(fq, entityName, this.resolver.resolveAndRequire(type, file).typeName, isEnumReference)
         }
@@ -522,7 +485,8 @@ class Visitor {
      */
     #printAspect(fq, aspect) {
         LOG.debug(`Printing aspect ${fq}`)
-        const { namespace, entityName, inflection } = this.entityRepository.getByFqOrThrow(fq)
+        const info = this.entityRepository.getByFqOrThrow(fq)
+        const { namespace, entityName, inflection } = info
         const file = this.fileRepository.getNamespaceFile(namespace)
         // 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.
@@ -530,6 +494,9 @@ class Visitor {
         file.addClass(entityName, fq)
         file.aspects.add(`// the following represents the CDS aspect '${entityName}'`)
         this.#aspectify(fq, aspect, file.aspects, { cleanName: inflection.singular })
+        if (!isType(aspect)) {
+            this.#printPlural(info, file.aspects)
+        }
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.30.0",
+  "version": "0.32.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",
@@ -42,7 +42,7 @@
     "cds-typer": "./lib/cli.js"
   },
   "peerDependencies": {
-    "@cap-js/cds-types": ">=0.6.4",
+    "@cap-js/cds-types": ">=0.9",
     "@sap/cds": ">=8"
   },
   "devDependencies": {