@cap-js/cds-typer 0.19.0 → 0.20.0

package/CHANGELOG.md

@@ -4,14 +4,30 @@ 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.20.0 - TBD
+## Version 0.21.0 - TBD
+
+## Version 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`.
+- Plural types can now also contain an optional numeric `$count` property
+
+### Changed
+- Empty `.actions` properties and operations without parameters are now typed as `Record<never, never>` to make it clear they contain nothing and also to satisfy overzealous linters
+
+### Fixed
+- Composition of aspects now properly resolve implicit `typeof` references in their properties
+- Importing an enum into a service will now generate an alias to the original enum, instead of incorrectly duplicating the definition
+- Returning entities from actions/ functions and using them as parameters will now properly use the singular inflection instead of returning an array thereof
+- 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
 ### Added
 - Support for `cds.Vector`, which will be represented as `string`
 
 ## Version 0.18.2 - 2024-03-21
-### Fix
+### 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
 

package/lib/cli.js

@@ -21,7 +21,7 @@ const flags = {
         desc: 'This text.',
     },
     logLevel: {
-        desc: `Minimum log level that is printed.`,
+        desc: 'Minimum log level that is printed.',
         allowed: Object.keys(Levels),
         default: Levels.ERROR,
     },
@@ -48,7 +48,7 @@ const hint = () => 'Missing or invalid parameter(s). Call with --help for more d
 const indent = (s, indentation) => s.split(EOL).map(line => `${indentation}${line}`).join(EOL)
 
 const help = () => `SYNOPSIS${EOL2}` +
-        indent(`cds-typer [cds file | "*"]`, '  ') + EOL2 +
+        indent('cds-typer [cds file | "*"]', '  ') + EOL2 +
         indent(`Generates type information based on a CDS model.${EOL}Call with at least one positional parameter pointing${EOL}to the (root) CDS file you want to compile.`, '  ') + EOL2 +
             `OPTIONS${EOL2}` +
             Object.entries(flags)
@@ -67,11 +67,11 @@ const help = () => `SYNOPSIS${EOL2}` +
                     s += `${EOL2}${indent(value.desc, '    ')}`
                     return s
                 }
-            ).join(EOL2)
+                ).join(EOL2)
 
 const version = () => require('../package.json').version
 
-const main = async (args) => {
+const main = async args => {
     if ('help' in args.named) {
         console.log(help())
         process.exit(0)

package/lib/compile.js

@@ -38,18 +38,6 @@ const writeJsConfig = (path, logger) => {
     fs.writeFileSync(path, JSON.stringify(values, null, 2))
 }
 
-/**
- * Compiles a .cds file to Typescript types.
- * @param inputFile {string} path to input .cds file
- * @param parameters {CompileParameters} path to root directory for all generated files, min log level, etc.
- */
-const compileFromFile = async (inputFile, parameters) => {
-    const paths = typeof inputFile === 'string' ? normalize(inputFile) : inputFile.map(f => normalize(f))
-    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 {{xtended: CSN, inferred: CSN}} csn
@@ -69,6 +57,18 @@ const compileFromCSN = async (csn, parameters) => {
     )
 }
 
+/**
+ * Compiles a .cds file to Typescript types.
+ * @param inputFile {string} path to input .cds file
+ * @param parameters {CompileParameters} path to root directory for all generated files, min log level, etc.
+ */
+const compileFromFile = async (inputFile, parameters) => {
+    const paths = typeof inputFile === 'string' ? normalize(inputFile) : inputFile.map(f => normalize(f))
+    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)
+}
+
 module.exports = {
     compileFromFile
 }

package/lib/components/basedefs.js

@@ -0,0 +1,64 @@
+const { SourceFile } = require('../file')
+
+// eslint-disable-next-line no-template-curly-in-string
+const dateRegex = '`${number}${number}${number}${number}-${number}${number}-${number}${number}`'
+// eslint-disable-next-line no-template-curly-in-string
+const timeRegex = '`${number}${number}:${number}${number}:${number}${number}`'
+
+/**
+ * Base definitions used throughout the typing process,
+ * such as Associations and Compositions.
+ * @type {SourceFile}
+ */
+const baseDefinitions = new SourceFile('_')
+// FIXME: this should be a library someday
+baseDefinitions.addPreamble(`
+export namespace Association {
+    export type to <T> = T;
+    export namespace to {
+        export type many <T extends readonly any[]> = T;
+    }
+}
+
+export namespace Composition {
+    export type of <T> = T;
+    export namespace of {
+        export type many <T extends readonly any[]> = T;
+    }
+}
+
+export class Entity {
+    static data<T extends Entity> (this:T, _input:Object) : T {
+        return {} as T // mock
+    }
+}
+
+export type EntitySet<T> = T[] & {
+    data (input:object[]) : T[]
+    data (input:object) : T
+};
+
+export type DeepRequired<T> = { 
+    [K in keyof T]: DeepRequired<T[K]>
+} & Exclude<Required<T>, null>;
+
+
+/**
+ * Dates and timestamps are strings during runtime, so cds-typer represents them as such.
+ */
+export type CdsDate = ${dateRegex};
+/**
+ * @see {@link CdsDate}
+ */
+export type CdsDateTime = string;
+/**
+ * @see {@link CdsDate}
+ */
+export type CdsTime = ${timeRegex};
+/**
+ * @see {@link CdsDate}
+ */
+export type CdsTimestamp = string;
+`)
+
+module.exports = { baseDefinitions }

package/lib/components/enum.js

@@ -1,5 +1,26 @@
 const { normalise } = require('./identifier')
 
+/**
+ * Extracts all unique values from a list of enum key-value pairs.
+ * If the value is an object, then the `.val` property is used.
+ * @param {[string, any | {val: any}][]} kvs
+ */
+const uniqueValues = kvs => new Set(kvs.map(([,v]) => v?.val ?? v))  // in case of wrapped vals we need to unwrap here for the type
+
+/**
+ * Stringifies a list of enum key-value pairs into the righthand side of a TS type.
+ * @param {[string, string][]} kvs list of key-value pairs
+ * @returns {string} a stringified type
+ * @example
+ * ```js
+ * ['A', 'B', 'A'] // -> '"A" | "B"'
+ * ```
+ */
+const stringifyEnumType = kvs => [...uniqueValues(kvs)].join(' | ')
+
+// in case of strings, wrap in quotes and fallback to key to make sure values are attached for every key
+const enumVal = (key, value, enumType) => enumType === 'cds.String' ? JSON.stringify(`${value ?? key}`) : value
+
 /**
  * Prints an enum to a buffer. To be precise, it prints
  * a constant object and a type which together form an artificial enum.
@@ -30,33 +51,12 @@ function printEnum(buffer, name, kvs, options = {}) {
     const opts = {...{export: true}, ...options} 
     buffer.add('// enum')
     buffer.addIndentedBlock(`${opts.export ? 'export ' : ''}const ${name} = {`, () =>
-        kvs.forEach(([k, v]) => buffer.add(`${normalise(k)}: ${v},`))
+        kvs.forEach(([k, v]) => { buffer.add(`${normalise(k)}: ${v},`) })
     , '} as const;')
     buffer.add(`${opts.export ? 'export ' : ''}type ${name} = ${stringifyEnumType(kvs)}`)
     buffer.add('')
 }
 
-/**
- * Stringifies a list of enum key-value pairs into the righthand side of a TS type.
- * @param {[string, string][]} kvs list of key-value pairs
- * @returns {string} a stringified type
- * @example
- * ```js
- * ['A', 'B', 'A'] // -> '"A" | "B"'
- * ```
- */
-const stringifyEnumType = kvs => [...uniqueValues(kvs)].join(' | ')
-
-/**
- * Extracts all unique values from a list of enum key-value pairs.
- * If the value is an object, then the `.val` property is used.
- * @param {[string, any | {val: any}][]} kvs
- */
-const uniqueValues = kvs => new Set(kvs.map(([,v]) => v?.val ?? v))  // in case of wrapped vals we need to unwrap here for the type
-
-// in case of strings, wrap in quotes and fallback to key to make sure values are attached for every key
-const  enumVal = (key, value, enumType) => enumType === 'cds.String' ? JSON.stringify(`${value ?? key}`) : value
-
 /**
  * Converts a CSN type describing an enum into a list of kv-pairs.
  * Values from CSN are unwrapped from their `.val` structure and

package/lib/components/reference.js

@@ -16,7 +16,7 @@
  * @param {{type: any}} element
  * @returns boolean
  */
-const isReferenceType = (element) => element.type && Object.hasOwn(element.type, 'ref')
+const isReferenceType = element => element.type && Object.hasOwn(element.type, 'ref')
 
 module.exports = {
     isReferenceType

package/lib/components/resolver.js

@@ -2,11 +2,13 @@
 
 const util = require('../util')
 // eslint-disable-next-line no-unused-vars
-const { Buffer, SourceFile, Path, Library, baseDefinitions } = require('../file')
+const { Buffer, SourceFile, Path, Library } = require('../file')
 const { deepRequire, createToManyAssociation, createToOneAssociation, createArrayOf, createCompositionOfMany, createCompositionOfOne } = require('./wrappers')
 const { StructuredInlineDeclarationResolver } = require('./inline')
 const { isInlineEnumType, propertyToInlineEnumName } = require('./enum')
 const { isReferenceType } = require('./reference')
+const { isEntity } = require('../csn')
+const { baseDefinitions } = require('./basedefs')
 
 /** @typedef {{ cardinality?: { max?: '*' | number } }} EntityCSN */
 /** @typedef {{ definitions?: Object<string, EntityCSN> }} CSN */
@@ -24,6 +26,7 @@ const { isReferenceType } = require('./reference')
  * ```
  * @typedef {{
  *    isBuiltin: boolean,
+ *    isDeepRequire: boolean,
  *    isNotNull: boolean,
  *    isInlineDeclaration: boolean,
  *    isForeignKeyReference: boolean,
@@ -58,10 +61,10 @@ const Builtins = {
     Double: 'number',
     Boolean: 'boolean',
     // note: the date-related types are strings on purpose, which reflects their runtime behaviour
-    Date: 'string',  // yyyy-mm-dd
-    DateTime: 'string', // yyyy-mm-dd + time + TZ (precision: seconds
-    Time: 'string',
-    Timestamp: 'string', // yyy-mm-dd + time + TZ (ms precision)
+    Date: '__.CdsDate',  // yyyy-mm-dd
+    DateTime: '__.CdsDateTime', // yyyy-mm-dd + time + TZ (precision: seconds)
+    Time: '__.CdsTime',  // hh:mm:ss
+    Timestamp: '__.CdsTimestamp', // yyy-mm-dd + time + TZ (ms precision)
     //
     Composition: 'Array',
     Association: 'Array'
@@ -88,7 +91,7 @@ class Resolver {
          */
         namespaces: {},
         /**
-         * @type {{ [qualifier: string]: string }}
+         * @type {{ [qualifier: string]: string[] }}
          */
         propertyAccesses: {}
     }
@@ -103,12 +106,28 @@ class Resolver {
 
     /**
      * @param {string} qualifier
-     * @returns {string?}
+     * @param {string} namespace
+     */
+    #cacheNamespace (qualifier, namespace) {
+        this.#caches.namespaces[qualifier] = namespace
+    }
+
+    /**
+     * @param {string} qualifier
+     * @returns {string[]?}
      */
     #getCachedPropertyAccess (qualifier) {
         return this.#caches.propertyAccesses[qualifier]
     }
 
+    /**
+     * @param {string} qualifier
+     * @param {string[]} propertyAccess
+     */
+    #cachePropertyAccess (qualifier, propertyAccess) {
+        this.#caches.propertyAccesses[qualifier] = propertyAccess
+    }
+
     get csn() { return this.visitor.csn.inferred }
     
     /** @param {Visitor} visitor */
@@ -118,6 +137,12 @@ class Resolver {
 
         /** @type {Library[]} */
         this.libraries = [new Library(require.resolve('../../library/cds.hana.ts'))]
+
+        /**
+         * @type {StructuredInlineDeclarationResolver}
+         * needed for inline declarations
+         */
+        this.structuredInlineResolver = new StructuredInlineDeclarationResolver(this.visitor)
     }   
     
     /**
@@ -128,17 +153,40 @@ class Resolver {
         return this.libraries.filter(l => l.referenced)
     }
 
+    /**
+     * TODO: this should probably be a class where we can also cache the properties
+     * and only retrieve them on demand
+     * @typedef {Object} Untangled 
+     * @property {string[]} scope in case the entity is wrapped in another entity `a.b.C.D.E.f.g` -> `[C,D]`
+     * @property {string} name name of the leaf entity `a.b.C.D.E.f.g` -> `E`
+     * @property {string[]} property the property access path `a.b.C.D.E.f.g` -> `[f,g]`
+     * @property {Path} namespace the cds namespace of the entity `a.b.C.D.E.f.g` -> `a.b`
+     */
+
     /**
      * Conveniently combines resolveNamespace and trimNamespace
      * to end up with both the resolved Path of the namespace,
      * and the clean name of the class.
      * @param {string} fq the fully qualified name of an entity.
-     * @returns {[Path, string, string[]]} a tuple, [0] holding the path to the namespace, [1] holding the clean name of the entity, [2] holding chained property accesses
+     * @returns {Untangled} untangled qualifier
      */
     untangle(fq) {
-        const ns = this.resolveNamespace(fq.split('.'))
-        const name = this.trimNamespace(fq).split('.').at(-1)  // nested entities would return Foo.Bar, so we only take the last part to get the actual entity name
-        return [new Path(ns.split('.')), name, this.findPropertyAccess(name)]
+        const builtin = resolveBuiltin(fq)
+        if (builtin) return { namespace: new Path([]), name: builtin, property: [], scope: [] }
+
+        const ns = this.resolveNamespace(fq)
+        const nameAndProperty = this.trimNamespace(fq)
+        const property = this.findPropertyAccess(fq)
+        const nameParts = (property.length
+            ? nameAndProperty.slice(0, -(property.join('').length + property.length)) // +1 for each dot
+            : nameAndProperty
+        ).split('.')//.at(-1)  // nested entities would return Foo.Bar, so we only take the last part to get the actual entity name
+        return { 
+            namespace: new Path(ns.split('.')),
+            scope: nameParts.slice(0, -1),
+            name: nameParts.at(-1),
+            property
+        }
     }
 
     /**
@@ -152,7 +200,7 @@ class Resolver {
      * @returns {string} the entity name without leading namespace.
      */
     trimNamespace(p) {
-        if (this.#getCachedNamespace(p)) return this.#getCachedNamespace(p)
+        //if (this.#getCachedNamespace(p)) return this.#getCachedNamespace(p)
         const parts = p.split('.')
         if (parts.length <= 1) return p
 
@@ -172,6 +220,7 @@ class Resolver {
      * From a fully qualified path, finds the parts that are property accesses.
      * This are specifically used in CDS' `typeof` syntax, where a property can
      * refer to another entity's property type.
+     * @param {string} p path
      * @example
      * ```
      * namespace namespace;
@@ -198,19 +247,24 @@ class Resolver {
         const parts = p.split('.')
         if (parts.length <= 1) return []
 
-        // 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"
-        // sadly we have to use the extended flavour here, as inferred csn contains artificial entities for
-        // this kind of property access
-        const defs = this.visitor.csn.xtended.definitions
-        const properties = []
-        let qualifier = parts.join('.')
-        while (!defs[qualifier] && parts.length) {
-            properties.unshift(parts.pop())
-            qualifier = parts.join('.')
-        }
+        const isPropertyOf = (property, entity) => entity && property && Object.hasOwn(entity?.elements, property)
 
-        return properties
+        const defs = this.visitor.csn.inferred.definitions
+        // assume parts to contain [Namespace, Service, Entity1, Entity2, Entity3, property1, property2]
+        let qualifier = parts.shift()
+        // find first entity from left (Entity1)
+        while ((!defs[qualifier] || !isEntity(defs[qualifier])) && parts.length) {
+            qualifier += `.${parts.shift()}`
+        }
+        // skip forward to the last entity from left (Entity3), assuming that there is no name conflict between entities and properties
+        // i.e.: if there is a property "Entity2" in the entity Entity1, this will instead [Entity2, Entity3, property1, property2] as property access 
+        while (!isPropertyOf(parts[0], defs[qualifier]) && isEntity(defs[qualifier + `.${parts[0]}`])) {
+            qualifier += `.${parts.shift()}`
+        }
+        // assuming Entity3 _does_ own a property "property1", return [property1, property2]
+        const propertyAccess = isPropertyOf(parts[0], defs[qualifier]) ? parts : []
+        this.#cachePropertyAccess(p, propertyAccess)
+        return propertyAccess
     }
 
     /**
@@ -252,7 +306,7 @@ class Resolver {
             // If stringifyLambda(...) is the only place where we need this, we should have stringifyLambda call this
             // piece of code instead to reduce overhead.
             const into = new Buffer()
-            new StructuredInlineDeclarationResolver(this.visitor).printInlineType(undefined, { typeInfo }, into, '')
+            this.structuredInlineResolver.printInlineType(undefined, { typeInfo }, into, '')
             typeName = into.join(' ')
             singular = typeName
             plural = createArrayOf(typeName)
@@ -318,10 +372,29 @@ class Resolver {
                 const target = element.items ?? (typeof element.target === 'string' ? { type: element.target } : element.target)
                 /** set `notNull = true` to avoid repeated `| not null` TS construction */
                 target.notNull = true
-                const { singular, plural } = this.resolveAndRequire(target, file).typeInfo.inflection
-                typeName =
-                    cardinality > 1 ? toMany(plural) : toOne(this.visitor.isSelfReference(target) ? 'this' : singular)
-                file.addImport(baseDefinitions.path)
+                const targetTypeInfo = this.resolveAndRequire(target, file)
+                if (targetTypeInfo.typeInfo.isDeepRequire === true) {
+                    typeName = cardinality > 1 ? toMany(targetTypeInfo.typeName) : toOne(targetTypeInfo.typeName)
+                } 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.untangle(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)
+                    file.addImport(baseDefinitions.path)
+                }
             }
         } else {
             // TODO: this could go into resolve type
@@ -344,6 +417,7 @@ class Resolver {
                     const [, ...members] = element.type.ref
                     const lookup = this.visitor.inlineDeclarationResolver.getTypeLookup(members)
                     typeName = deepRequire(typeInfo.inflection.singular, lookup)
+                    typeInfo.isDeepRequire = true
                     file.addImport(baseDefinitions.path)
                 }
             }
@@ -360,11 +434,17 @@ class Resolver {
             typeInfo.inflection = this.inflect(typeInfo)
         }
 
-        const [,,propertyAccess] = this.untangle(typeName)
-        if (propertyAccess.length) {
-            const element = typeName.slice(0, -propertyAccess.join('.').length - 1)
-            const access = this.visitor.inlineDeclarationResolver.getTypeLookup(propertyAccess)
-            typeName = deepRequire(element) + access            
+        // 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 { property: propertyAccess } = this.untangle(target)
+            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
+                typeName = deepRequire(util.singular4(element)) + access
+                typeInfo.isDeepRequire = true          
+            }
         }
 
         // add fallback inflection. Mainly needed for array-of with builtin types.
@@ -410,9 +490,9 @@ class Resolver {
      * @returns {string} the namespace's name, i.e. 'a.b.c'.
      */
     resolveNamespace(pathParts) {
-        if (typeof pathParts === 'string') {
-            pathParts = pathParts.split('.')
-        }
+        if (typeof pathParts === 'string') pathParts = pathParts.split('.')
+        const fq = pathParts.join('.')
+        if (this.#getCachedNamespace(fq)) return this.#getCachedNamespace(fq)
         let result
         while (result === undefined) {
             const path = pathParts.join('.')
@@ -425,6 +505,7 @@ class Resolver {
                 pathParts = pathParts.slice(0, -1)
             }
         }
+        this.#cacheNamespace(fq, result)
         return result
     }
 
@@ -457,40 +538,38 @@ class Resolver {
             // later on with an inline declaration
             result.type = '{}'
             result.isInlineDeclaration = true
-        } else {
-            if (!isReferenceType(element) && isInlineEnumType(element, this.csn)) {
-                // element.parent is only set if the enum is attached to an entity's property.
-                // If it is missing then we are dealing with an inline parameter type of an action.
-                // Edge case: element.parent is set, but no .name property is attached. This happens
-                // for inline enums inside types:
-                // ```cds
-                // type T {
-                //   x : String enum { ... };  // no element.name for x
-                // }
-                // ```
-                // In that case, we currently resolve to the more general type (cds.String, here)
-                if (element.parent?.name) {
-                    result.isInlineDeclaration = true
-                    // we use the singular as the initial declaration of these enums takes place
-                    // while defining the singular class. Which therefore uses the singular over the plural name.
-                    const cleanEntityName = util.singular4(element.parent, true)
-                    const enumName = propertyToInlineEnumName(cleanEntityName, element.name)
-                    result.type = enumName
-                    result.plainName = enumName
-                } else {
-                    // FIXME: this is the case where users have arrays of enums as action parameter type.
-                    // Instead of building the proper type (e.g. `'A' | 'B' | ...`, we are instead building
-                    // the encasing type (e.g. `string` here)
-                    // We should instead aim for a proper type, i.e. 
-                    // this.#resolveInlineDeclarationType(element.enum, result, file)
-                    // or
-                    // stringifyEnumType(csnToEnumPairs(element))
-                    this.#resolveTypeName(element.type, result)
-                }
+        } else if (!isReferenceType(element) && isInlineEnumType(element, this.csn)) {
+            // element.parent is only set if the enum is attached to an entity's property.
+            // If it is missing then we are dealing with an inline parameter type of an action.
+            // Edge case: element.parent is set, but no .name property is attached. This happens
+            // for inline enums inside types:
+            // ```cds
+            // type T {
+            //   x : String enum { ... };  // no element.name for x
+            // }
+            // ```
+            // In that case, we currently resolve to the more general type (cds.String, here)
+            if (element.parent?.name) {
+                result.isInlineDeclaration = true
+                // we use the singular as the initial declaration of these enums takes place
+                // while defining the singular class. Which therefore uses the singular over the plural name.
+                const cleanEntityName = util.singular4(element.parent, true)
+                const enumName = propertyToInlineEnumName(cleanEntityName, element.name)
+                result.type = enumName
+                result.plainName = enumName
             } else {
-                this.resolvePotentialReferenceType(element.type, result, file)
-            }            
-        }
+                // FIXME: this is the case where users have arrays of enums as action parameter type.
+                // Instead of building the proper type (e.g. `'A' | 'B' | ...`, we are instead building
+                // the encasing type (e.g. `string` here)
+                // We should instead aim for a proper type, i.e. 
+                // this.#resolveInlineDeclarationType(element.enum, result, file)
+                // or
+                // stringifyEnumType(csnToEnumPairs(element))
+                this.#resolveTypeName(element.type, result)
+            }
+        } else {
+            this.resolvePotentialReferenceType(element.type, result, file)
+        }            
 
         // objects and arrays
         if (element?.items) {
@@ -506,9 +585,7 @@ class Resolver {
         }
 
         if (result.isBuiltin === false && result.isInlineDeclaration === false && !result.plainName) {
-            this.logger.warning(
-                `Plain name is empty for ${element?.type ?? '<empty>'}. This will probably cause issues.`
-            )
+            this.logger.warning(`Plain name is empty for ${element?.type ?? '<empty>'}. This will probably cause issues.`)
         }
         return result
     }
@@ -585,7 +662,7 @@ class Resolver {
             result.plainName = 'this'
         } else {
             // type offered by some library
-            const lib = this.libraries.find((lib) => lib.offers(t))
+            const lib = this.libraries.find(lib => lib.offers(t))
             if (lib) {
                 // only use the last name of the (fully qualified) type name in this case.
                 // We can not use trimNamespace, as that actually does a semantic lookup within the CSN.

package/lib/components/typescript.js

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

package/lib/components/wrappers.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const base = require('../file').baseDefinitions.path.asIdentifier()
+// this was derived from baseDefinitions before, but caused a circular dependency
+const base = '__'
 
 /**
  * Wraps type into association to scalar.
@@ -37,6 +38,13 @@ const createCompositionOfMany = t => `${base}.Composition.of.many<${t}>`
  */
 const createArrayOf = t => `Array<${t}>`
 
+/**
+ * Wraps type into object braces
+ * @param {string} t the properties, stringified and comma separated.
+ * @returns {string}
+ */
+const createObjectOf = t => `{${t}}`
+
 /**
  * Wraps type into a deep require (removes all posibilities of undefined recursively).
  * @param {string} t the singular type name. 
@@ -52,11 +60,12 @@ const deepRequire = (t, lookup = '') => `${base}.DeepRequired<${t}>${lookup}`
  *          concatenated to be properly indented by `buffer.add(...)`.
  */
 const docify = doc => doc 
-    ? ['/**'].concat(doc.split('\n').map((line) => `* ${line}`)).concat(['*/']) 
+    ? ['/**'].concat(doc.split('\n').map(line => `* ${line}`)).concat(['*/']) 
     : []
 
 module.exports = {
     createArrayOf,
+    createObjectOf,
     createToOneAssociation,
     createToManyAssociation,
     createCompositionOfOne,