@cap-js/cds-typer 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -4,12 +4,20 @@ 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.23.0 - TBD
+## Version 0.24.0 - TBD
+
+## Version 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
 ### Fixed
 - Fixed a bug where keys would sometimes inconsistently become nullable
 
+### 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
 ### Fixed
 - The typescript build task will no longer attempt to run unless at least cds 8 is installed

package/cds-plugin.js

@@ -33,7 +33,7 @@ const rmDirIfExists = dir => {
  * @param {string[]} exts - The extensions to remove.
  * @returns {Promise<void>}
  */
-const rmFiles = async (dir, exts) => fs.existsSync(dir) 
+const rmFiles = async (dir, exts) => fs.existsSync(dir)
     ? Promise.all(
         (await readdir(dir))
             .map(async file => {
@@ -66,7 +66,7 @@ cds.build?.register?.('typescript', class extends cds.build.Plugin {
     get #modelDirectoryName () {
         try {
             // expected format: { '#cds-models/*': [ './@cds-models/*/index.ts' ] }
-            //                                       ^^^^^^^^^^^^^^^ 
+            //                                       ^^^^^^^^^^^^^^^
             //                             relevant part - may be changed by user
             const config = JSON.parse(fs.readFileSync ('tsconfig.json', 'utf8'))
             const alias = config.compilerOptions.paths['#cds-models/*'][0]
@@ -118,8 +118,8 @@ cds.build?.register?.('typescript', class extends cds.build.Plugin {
         await rmFiles(this.task.dest, ['.js', '.ts'])
 
         try {
-            await (buildConfigExists() 
-                ? this.#buildWithConfig() 
+            await (buildConfigExists()
+                ? this.#buildWithConfig()
                 : this.#buildWithoutConfig()
             )
         } catch (error) {

package/lib/cli.js

@@ -2,9 +2,10 @@
 /* eslint-disable no-console */
 'use strict'
 
+const cds = require('@sap/cds')
 const { compileFromFile } = require('./compile')
 const { parseCommandlineArgs } = require('./util')
-const { Levels } = require('./logging')
+const { deprecated, _keyFor } = require('./logging')
 const path = require('path')
 const { EOL } = require('node:os')
 
@@ -21,9 +22,11 @@ const flags = {
         desc: 'This text.',
     },
     logLevel: {
-        desc: 'Minimum log level that is printed.',
-        allowed: Object.keys(Levels),
-        default: Levels.ERROR,
+        desc: `Minimum log level that is printed.${EOL}The default is only used if no explicit value is passed${EOL}and there is no configuration passed via cds.env either.`,
+        allowed: Object.keys(cds.log.levels).concat(Object.keys(deprecated)),
+        allowedHint: Object.keys(cds.log.levels).join(' | '),  // FIXME: remove once old levels are faded out
+        defaultHint: _keyFor(cds.log.levels.ERROR),
+        default: cds?.env?.log?.levels?.['cds-typer'] ?? _keyFor(cds.log.levels.ERROR),
     },
     jsConfigPath: {
         desc: `Path to where the jsconfig.json should be written.${EOL}If specified, ${toolName} will create a jsconfig.json file and${EOL}set it up to restrict property usage in types entities to${EOL}existing properties only.`,
@@ -60,14 +63,16 @@ const help = () => `SYNOPSIS${EOL2}` +
                 .sort()
                 .map(([key, value]) => {
                     let s = indent(`--${key}`, '  ')
-                    if (value.allowed) {
+                    if (value.allowedHint) {
+                        s += ` ${value.allowedHint}`
+                    } else if (value.allowed) {
                         s += `: <${value.allowed.join(' | ')}>`
                     } else if (value.type) {
                         s += `: <${value.type}>`
                     }
-                    if (value.default) {
+                    if (value.defaultHint || value.default) {
                         s += EOL
-                        s += indent(`(default: ${value.default})`, '    ')
+                        s += indent(`(default: ${value.defaultHint ?? value.default})`, '    ')
                     }
                     s += `${EOL2}${indent(value.desc, '    ')}`
                     return s
@@ -92,10 +97,16 @@ const main = async args => {
     if (args.named.jsConfigPath && !args.named.jsConfigPath.endsWith('jsconfig.json')) {
         args.named.jsConfigPath = path.join(args.named.jsConfigPath, 'jsconfig.json')
     }
+    const newLogLevel = deprecated[args.named.logLevel]
+    if (newLogLevel) {
+        console.warn(`deprecated log level '${args.named.logLevel}', use '${newLogLevel}' instead (changing this automatically for now).`)
+        args.named.logLevel = newLogLevel
+    }
+
     compileFromFile(args.positional, {
         // temporary fix until rootDir is faded out
         outputDirectory: [args.named.outputDirectory, args.named.rootDir].find(d => d !== './') ?? './',
-        logLevel: Levels[args.named.logLevel] ?? args.named.logLevel,
+        logLevel: args.named.logLevel,
         jsConfigPath: args.named.jsConfigPath,
         inlineDeclarations: args.named.inlineDeclarations,
         propertiesOptional: args.named.propertiesOptional === 'true',

package/lib/compile.js

@@ -5,21 +5,20 @@ const { normalize } = require('path')
 const cds = require(require.resolve('@sap/cds', { paths: [process.cwd(), __dirname] }))
 const util = require('./util')
 const { writeout } = require('./file')
-const { Logger } = require('./logging')
 const { Visitor } = require('./visitor')
+const { LOG, setLevel } = require('./logging')
 
 /**
- * @typedef {import('./visitor').CompileParameters} CompileParameters
+ * @typedef {import('./typedefs').visitor.CompileParameters} CompileParameters
  */
 
 /**
  * Writes the accompanying jsconfig.json file to the specified paths.
  * Tries to merge nicely if an existing file is found.
  * @param {string} path - filepath to jsconfig.json.
- * @param {import('./logging').Logger} logger - logger
  * @private
  */
-const writeJsConfig = (path, logger) => {
+const writeJsConfig = path => {
     let values = {
         compilerOptions: {
             checkJs: true,
@@ -29,7 +28,7 @@ const writeJsConfig = (path, logger) => {
     if (fs.existsSync(path)) {
         const currentContents = JSON.parse(fs.readFileSync(path))
         if (currentContents?.compilerOptions?.checkJs) {
-            logger.warning(`jsconfig at location ${path} already exists. Attempting to merge.`)
+            LOG.warn(`jsconfig at location ${path} already exists. Attempting to merge.`)
         }
         util.deepMerge(currentContents, values)
         values = currentContents
@@ -40,20 +39,19 @@ const writeJsConfig = (path, logger) => {
 
 /**
  * Compiles a CSN object to Typescript types.
- * @param {{xtended: CSN, inferred: CSN}} csn
+ * @param {{xtended: CSN, inferred: CSN}} csn - csn tuple
  * @param {CompileParameters} parameters - path to root directory for all generated files, min log level
  */
 const compileFromCSN = async (csn, parameters) => {
     const envSettings = cds.env?.typer ?? {}
     parameters = { ...envSettings, ...parameters }
-    const logger = new Logger()
-    logger.addFrom(parameters.logLevel)
+    setLevel(parameters.logLevel)
     if (parameters.jsConfigPath) {
-        writeJsConfig(parameters.jsConfigPath, logger)
+        writeJsConfig(parameters.jsConfigPath)
     }
     return writeout(
         parameters.outputDirectory,
-        Object.values(new Visitor(csn, parameters, logger).getWriteoutFiles())
+        Object.values(new Visitor(csn, parameters).getWriteoutFiles())
     )
 }
 

package/lib/components/enum.js

@@ -3,7 +3,7 @@ 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
+ * @param {[string, any | {val: any}][]} kvs - key value pairs
  */
 const uniqueValues = kvs => new Set(kvs.map(([,v]) => v?.val ?? v))  // in case of wrapped vals we need to unwrap here for the type
 
@@ -44,10 +44,10 @@ const enumVal = (key, value, enumType) => enumType === 'cds.String' ? JSON.strin
  * @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
- * @param {object} options
+ * @param {object} options - options for printing the enum
  */
 function printEnum(buffer, name, kvs, options = {}) {
-    const opts = {...{export: true}, ...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},`) })
@@ -60,14 +60,14 @@ function printEnum(buffer, name, kvs, options = {}) {
  * 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 {{enum: {[key: name]: string}, type: string}} enumCsn
+ * @param {{enum: {[key: name]: string}, type: 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
  *  to mimic the runtime as closely as possible (inline enum types).
  *  Stripping that additional wrapper would be more readable for users.
  * @example
- * ```ts 
+ * ```ts
  * const csn = {enum: {X: {val: 'a'}, Y: {val: 'b'}, Z: {}}}
  * csnToEnumPairs(csn) // -> [['X', 'a'], ['Y': 'b'], ['Z': 'Z']]
  * csnToEnumPairs(csn, {unwrapVals: false}) // -> [['X', {val:'a'}], ['Y': {val:'b'}], ['Z':'Z']]
@@ -82,8 +82,8 @@ const csnToEnumPairs = ({enum: enm, type}, options = {}) => {
 }
 
 /**
- * @param {string} entity
- * @param {string} property
+ * @param {string} entity - the entity to which the property belongs
+ * @param {string} property - the property name
  */
 const propertyToInlineEnumName = (entity, property) => `${entity}_${property}`
 
@@ -91,8 +91,8 @@ const propertyToInlineEnumName = (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
+ * @param {{type: string}} element - the element to check
+ * @param {object} csn - the CSN model
  * @returns boolean
  */
 const isInlineEnumType = (element, csn) => element.enum && !(element.type in csn.definitions)
@@ -107,12 +107,12 @@ const isInlineEnumType = (element, csn) => element.enum && !(element.type in csn
  * }
  * ```
  * becomes
- * 
+ *
  * ```js
  * module.exports.Language = { DE: "German", EN: "English", FR: "FR" }
  * ```
- * @param {string} name
- * @param {[string, string][]} kvs - a list of key-value pairs. Values that are falsey are replaced by 
+ * @param {string} name - the enum name
+ * @param {[string, string][]} kvs - a list of key-value pairs. Values that are falsey are replaced by
  */
 // ??= for inline enums. If there is some static property of that name, we don't want to override it (for example: ".actions"
 const stringifyEnumImplementation = (name, kvs) => `module.exports.${name} ??= { ${kvs.map(([k,v]) => `${normalise(k)}: ${v}`).join(', ')} }`

package/lib/components/identifier.js

@@ -10,6 +10,14 @@ const normalise = ident => ident && !isValidIdent.test(ident)
     ? `"${ident}"`
     : ident
 
+/**
+ * Returns the last part of a dot-separated identifier.
+ * @param {string} ident - the identifier to extract the last part from
+ * @returns {string} the last part of the identifier
+ */
+const last = ident => ident.split('.').at(-1)
+
 module.exports = {
-    normalise
+    normalise,
+    last
 }

package/lib/components/inline.js

@@ -2,6 +2,8 @@ const { SourceFile, Buffer } = require('../file')
 const { normalise } = require('./identifier')
 const { docify } = require('./wrappers')
 
+/** @typedef {import('../resolution/resolver').TypeResolveInfo} TypeResolveInfo */
+
 /**
  * Inline declarations of types can come in different flavours.
  * The compiler can therefore be adjusted to print out one or the other
@@ -10,20 +12,20 @@ const { docify } = require('./wrappers')
  */
 class InlineDeclarationResolver {
     /**
-     * @param {string} name
-     * @param {import('./resolver').TypeResolveInfo} type
-     * @param {import('../file').Buffer} buffer
-     * @param {string} statementEnd
+     * @param {string} fq - full qualifier of the type
+     * @param {TypeResolveInfo} type - type info so far
+     * @param {import('../file').Buffer} buffer - the buffer to write into
+     * @param {string} statementEnd - statement ending character
      * @protected
      * @abstract
      */
     // eslint-disable-next-line no-unused-vars
-    printInlineType(name, type, buffer, statementEnd) { /* abstract */ }
+    printInlineType(fq, type, buffer, statementEnd) { /* abstract */ }
 
     /**
      * Attempts to resolve a type that could reference another type.
-     * @param {any} items 
-     * @param {import('./resolver').TypeResolveInfo} into - @see Visitor.resolveType
+     * @param {any} items - properties of the declaration we are resolving
+     * @param {TypeResolveInfo} into - @see Visitor.resolveType
      * @param {SourceFile} relativeTo - file to which the resolved type should be relative to
      * @public
      */
@@ -57,7 +59,7 @@ class InlineDeclarationResolver {
     /**
      * Visits a single element in an entity.
      * @param {string} name - name of the element
-     * @param {import('./resolver').CSN} element - CSN data belonging to the the element.
+     * @param {import('../resolution/resolver').CSN} element - CSN data belonging to the the element.
      * @param {SourceFile} file - the namespace file the surrounding entity is being printed into.
      * @param {Buffer} [buffer] - buffer to add the definition to. If no buffer is passed, the passed file's class buffer is used instead.
      * @public
@@ -87,7 +89,7 @@ class InlineDeclarationResolver {
 
     /**
      * It returns TypeScript datatype for provided TS property
-     * @param {{typeName: string, typeInfo: TypeResolveInfo & { inflection: Inflection } }} type
+     * @param {{typeName: string, typeInfo: TypeResolveInfo & { inflection: Inflection } }} type - type of the property
      * @param {string} typeName - name of the TypeScript property
      * @returns {string} the datatype to be presented on TypeScript layer
      * @public
@@ -96,7 +98,7 @@ class InlineDeclarationResolver {
         return type.typeInfo.isNotNull ? typeName : `${typeName} | null`
     }
 
-    /** @param {import('../visitor').Visitor} visitor */
+    /** @param {import('../visitor').Visitor} visitor - the visitor */
     constructor(visitor) {
         this.visitor = visitor
         // type resolution might recurse. This indicator is used to determine
@@ -114,7 +116,7 @@ class InlineDeclarationResolver {
      *     b: number
      *   }
      * }
-     * 
+     *
      * T['a']['b']  // number
      * ```
      * but especially with inline declarations, the access will differ between flattened and nested representations.
@@ -187,9 +189,9 @@ class FlatInlineDeclarationResolver extends InlineDeclarationResolver {
  * ```
  */
 class StructuredInlineDeclarationResolver extends InlineDeclarationResolver {
-    constructor(visitor) { 
+    constructor(visitor) {
         super(visitor)
-        this.printDepth = 0 
+        this.printDepth = 0
     }
 
     flatten(name, type, buffer, statementEnd = ';') {

package/lib/components/reference.js

@@ -12,7 +12,7 @@
  * y: E.x  // <- ref
  * }
  * ```
- * @param {{type: any}} element
+ * @param {{type: any}} element - the element
  * @returns boolean
  */
 const isReferenceType = element => element.type && Object.hasOwn(element.type, 'ref')

package/lib/components/wrappers.js

@@ -5,35 +5,35 @@ const base = '__'
 
 /**
  * Wraps type into association to scalar.
- * @param {string} t - the singular type name. 
+ * @param {string} t - the singular type name.
  * @returns {string}
  */
 const createToOneAssociation = t => `${base}.Association.to<${t}>`
 
 /**
  * Wraps type into association to vector.
- * @param {string} t - the singular type name. 
+ * @param {string} t - the singular type name.
  * @returns {string}
  */
 const createToManyAssociation = t => `${base}.Association.to.many<${t}>`
 
 /**
  * Wraps type into composition of scalar.
- * @param {string} t - the singular type name. 
+ * @param {string} t - the singular type name.
  * @returns {string}
  */
 const createCompositionOfOne = t => `${base}.Composition.of<${t}>`
 
 /**
  * Wraps type into composition of vector.
- * @param {string} t - the singular type name. 
+ * @param {string} t - the singular type name.
  * @returns {string}
  */
 const createCompositionOfMany = t => `${base}.Composition.of.many<${t}>`
 
 /**
  * Wraps type into an array.
- * @param {string} t - the singular type name. 
+ * @param {string} t - the singular type name.
  * @returns {string}
  */
 const createArrayOf = t => `Array<${t}>`
@@ -47,7 +47,7 @@ const createObjectOf = t => `{${t}}`
 
 /**
  * Wraps type into a deep require (removes all posibilities of undefined recursively).
- * @param {string} t - the singular type name. 
+ * @param {string} t - the singular type name.
  * @param {string?} lookup - a property lookup of the required type (`['Foo']`)
  * @returns {string}
  */
@@ -59,8 +59,8 @@ const deepRequire = (t, lookup = '') => `${base}.DeepRequired<${t}>${lookup}`
  * @returns {string[]} an array of lines wrapped in doc format. The result is not
  *          concatenated to be properly indented by `buffer.add(...)`.
  */
-const docify = doc => doc 
-    ? ['/**'].concat(doc.split('\n').map(line => `* ${line}`)).concat(['*/']) 
+const docify = doc => doc
+    ? ['/**'].concat(doc.split('\n').map(line => `* ${line}`)).concat(['*/'])
     : []
 
 module.exports = {

package/lib/csn.js

@@ -5,15 +5,20 @@ const annotation = '@odata.draft.enabled'
  * i.e. ones that have a query, but are not a cds level projection.
  * Those are still not expanded and we have to retrieve their definition
  * with all properties from the inferred model.
- * @param {any} entity
+ * @param {any} entity - the entity
  */
 const isView = entity => entity.query && !entity.projection
 
 const isProjection = entity => entity.projection
 
-const getViewTarget = entity => entity.query?.SELECT?.from?.ref?.[0]
+/**
+ * @param {any} entity - the entity
+ * @see isView
+ * Unresolved entities have to be looked up from inferred csn.
+ */
+const isUnresolved = entity => entity._unresolved === true
 
-const getProjectionTarget = entity => entity.projection?.from?.ref?.[0]
+const isCsnAny = entity => entity?.constructor?.name === 'any'
 
 const isDraftEnabled = entity => entity['@odata.draft.enabled'] === true
 
@@ -22,13 +27,20 @@ const isType = entity => entity?.kind === 'type'
 const isEntity = entity => entity?.kind === 'entity'
 
 /**
- * @param {any} entity
- * @see isView
- * Unresolved entities have to be looked up from inferred csn.
+ * Attempts to retrieve the max cardinality of a CSN for an entity.
+ * @param {EntityCSN} element - csn of entity to retrieve cardinality for
+ * @returns {number} max cardinality of the element.
+ * If no cardinality is attached to the element, cardinality is 1.
+ * If it is set to '*', result is Infinity.
  */
-const isUnresolved = entity => entity._unresolved === true
+const getMaxCardinality = element => {
+    const cardinality = element?.cardinality?.max ?? 1
+    return cardinality === '*' ? Infinity : parseInt(cardinality)
+}
 
-const isCsnAny = entity => entity?.constructor?.name === 'any'
+const getViewTarget = entity => entity.query?.SELECT?.from?.ref?.[0]
+
+const getProjectionTarget = entity => entity.projection?.from?.ref?.[0]
 
 class DraftUnroller {
     /** @type {Set<string>} */
@@ -36,7 +48,7 @@ class DraftUnroller {
     /** @type {{[key: string]: boolean}} */
     #draftable = {}
     /** @type {{[key: string]: string}} */
-    #projections 
+    #projections
     /** @type {object[]} */
     #entities
     #csn
@@ -56,7 +68,7 @@ class DraftUnroller {
      * @param {object | string} entity - entity to set draftable annotation for.
      * @param {boolean} value - whether the entity is draftable.
      */
-    #setDraftable(entity, value) { 
+    #setDraftable(entity, value) {
         if (typeof entity === 'string') entity = this.#getDefinition(entity)
         if (!entity) return  // inline definition -- not found in definitions
         entity[annotation] = value
@@ -75,10 +87,10 @@ class DraftUnroller {
     #getDraftable(entityOrName) {
         const entity = (typeof entityOrName === 'string')
             ? this.#getDefinition(entityOrName)
-            : entityOrName  
+            : entityOrName
         // assert(typeof entity !== 'string')
         const name = entity?.name ?? entityOrName
-        return this.#draftable[name] ??= this.#propagateInheritance(entity) 
+        return this.#draftable[name] ??= this.#propagateInheritance(entity)
     }
 
     /**
@@ -156,11 +168,11 @@ class DraftUnroller {
 /**
  * We are unrolling the @odata.draft.enabled annotations into related entities manually.
  * This includes three scenarios:
- * 
+ *
  * (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":
- * @param {any} csn
+ * @param {any} csn - the entity
  * @example
  * ```ts
  * ＠odata.draft.enabled true
@@ -170,7 +182,7 @@ class DraftUnroller {
  * entity A: T,F {}  // draft not enabled
  * entity B: F,T {}  // draft enabled
  * ```
- * 
+ *
  * (b) Draft enabled projections make the entity we project on draft enabled.
  * @example
  * ```ts
@@ -178,9 +190,9 @@ class DraftUnroller {
  * entity A as projection on B {}
  * entity B {}  // draft enabled
  * ```
- * 
+ *
  * (c) Entities that are draft enabled propagate this property down through compositions:
- * 
+ *
  * ```ts
  * ＠odata.draft.enabled: true
  * entity A {
@@ -201,7 +213,7 @@ function unrollDraftability(csn) {
  *
  * This explicit propagation is required to add foreign key relations
  * to referring entities.
- * @param {any} csn
+ * @param {any} csn - the entity
  * @example
  * ```cds
  * entity A: cuid { key name: String; }
@@ -209,10 +221,10 @@ function unrollDraftability(csn) {
  * ```
  * must yield
  * ```ts
- * class A { 
+ * class A {
  *   ID: UUID // inherited from cuid
  *   name: String;
- * } 
+ * }
  * class B {
  *   ref: Association.to<A>
  *   ref_ID: UUID
@@ -235,7 +247,7 @@ function propagateForeignKeys(csn) {
                     const remoteKeys = Object.entries(this.associations ?? {})
                         .filter(([,{key}]) => key)  // only follow associations that are keys, that way we avoid cycles
                         .flatMap(([kname, key]) => Object.entries(csn.definitions[key.target].keys)
-                            .map(([ckname, ckey]) => [`${kname}_${ckname}`, ckey])) 
+                            .map(([ckname, ckey]) => [`${kname}_${ckname}`, ckey]))
 
                     this.__keys = Object.fromEntries(ownKeys
                         .concat(inheritedKeys)
@@ -251,7 +263,7 @@ function propagateForeignKeys(csn) {
 
 /**
  *
- * @param {any} csn
+ * @param {any} csn - complete csn
  */
 function amendCSN(csn) {
     unrollDraftability(csn)
@@ -274,14 +286,15 @@ const getProjectionAliases = entity => {
     return { aliases, all }
 }
 
-module.exports = { 
-    amendCSN, 
-    isView, 
+module.exports = {
+    amendCSN,
+    isView,
     isProjection,
     isDraftEnabled,
     isEntity,
     isUnresolved,
     isType,
+    getMaxCardinality,
     getProjectionTarget,
     getProjectionAliases,
     getViewTarget,