@cap-js/cds-typer 0.26.0 → 0.28.0

package/CHANGELOG.md

@@ -4,10 +4,34 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
-## Version 0.27.0 - TBD
+## Version 0.29.0 - TBD
+
+## Version 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
+- Schema definition for `typescript` cds build task.
+- `.drafts` property of any entity `E` is now of type `DraftOf<E>`, or `DraftsOf<E>` for plurals, respectively. This type exposes dditional properties that are available on drafts during runtime.
+
+### Fixed
+- Entity elements of named structured types are flattened when using the option `--inlineDeclarations flat`
+- `override` modifier on `.kind` property is now only generated if the property is actually inherited, satisfying strict `tsconfig.json`s
+- 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
+### 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.
+
+### Fixed
+- Fix build task for projects with spaces
+- 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
 ### 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.
 - Added a static `.kind` property for entities and types, which contains `'entity'` or `'type'` respectively
 - Apps need to provide `@sap/cds` version `8.2` or higher.
@@ -47,6 +71,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 
 ## Version 0.22.0 - 2024-06-20
+
 ### Fixed
 - Fixed a bug where keys would sometimes inconsistently become nullable
 

package/cds-plugin.js

@@ -36,7 +36,7 @@ const rmDirIfExists = dir => {
  * Remove files with given extensions from a directory recursively.
  * @param {string} dir - The directory to start from.
  * @param {string[]} exts - The extensions to remove.
- * @returns {Promise<void>}
+ * @returns {Promise<unknown>}
  */
 const rmFiles = async (dir, exts) => fs.existsSync(dir)
     ? Promise.all(
@@ -68,10 +68,15 @@ cds.build?.register?.('typescript', class extends cds.build.Plugin {
 
     get #appFolder () { return cds?.env?.folders?.app ?? 'app' }
 
+    /**
+     * cds.env > tsconfig.compilerOptions.paths > '@cds-models' (default)
+     */
     get #modelDirectoryName () {
+        const outputDirectory = cds.env.typer?.outputDirectory
+        if (outputDirectory) return outputDirectory
         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]
@@ -89,7 +94,9 @@ cds.build?.register?.('typescript', class extends cds.build.Plugin {
 
     async #runCdsTyper () {
         DEBUG?.('running cds-typer')
-        await typer.compileFromFile('*', { outputDirectory: this.#modelDirectoryName })
+        cds.env.typer ??= {}
+        cds.env.typer.outputDirectory ??= this.#modelDirectoryName
+        await typer.compileFromFile('*')
     }
 
     async #buildWithConfig () {
@@ -103,7 +110,7 @@ cds.build?.register?.('typescript', class extends cds.build.Plugin {
         DEBUG?.('building without config')
         // this will include gen/ that was created by the nodejs task
         // _within_ the project directory. So we need to remove it afterwards.
-        await exec(`npx tsc --outDir ${this.task.dest}`)
+        await exec(`npx tsc --outDir "${this.task.dest}"`)
         rmDirIfExists(path.join(this.task.dest, cds.env.build.target))
         rmDirIfExists(path.join(this.task.dest, this.#appFolder))
     }

package/lib/cli.js

@@ -2,20 +2,147 @@
 /* eslint-disable no-console */
 'use strict'
 
+/**
+ * @typedef {import('./typedefs').config.cli.ParameterSchema[number]} Parameter
+ */
+
 const cds = require('@sap/cds')
 const { compileFromFile } = require('./compile')
-const { parseCommandlineArgs } = require('./util')
+const { camelToSnake } = require('./util')
 const { deprecated, _keyFor } = require('./logging')
 const path = require('path')
 const { EOL } = require('node:os')
+const { camelSnakeHybrid, configuration } = require('./config')
 
 const EOL2 = EOL + EOL
 const toolName = 'cds-typer'
-
 // @ts-expect-error - nope, it is actually there. Types just seem to be out of sync.
 const lls = cds.log.levels
+const parameterTypes = {
+    boolean:
+    /**
+     * @param {Parameter} props - additional parameter properties
+     * @returns {Parameter}
+     */
+    props => ({...{
+        allowed: ['true', 'false'],
+        type: 'boolean',
+        postprocess: (/** @type {string} */ value) => value === 'true'
+    },
+    ...props})
+}
+
+/**
+ * Adds additional properties to the CLI parameter schema.
+ * @param {import('./typedefs').config.cli.ParameterSchema } flags - The CLI parameter schema.
+ * @returns {import('./typedefs').config.cli.ParameterSchema} - The enriched schema.
+ */
+const enrichFlagSchema = flags => {
+    const flagKeys = Object.keys(flags)
+    for (const [key, value] of Object.entries(flags)) {
+        /** @type {Parameter} */(value).camel = key;
+        /** @type {Parameter} */(value).snake = camelToSnake(key)
+    }
+    // non-enumerable utilities
+    Object.defineProperties(flags, {
+        hasFlag: {
+            value: (/** @type {string} **/ flag) => Object.values(flags).some(f => f.snake === flag || f.camel === flag)
+        },
+        keys: {
+            value: flagKeys
+        }
+    })
+    return camelSnakeHybrid(flags)
+}
+
+/**
+ * Parses command line arguments into named and positional parameters.
+ * Named parameters are expected to start with a double dash (--).
+ * If the next argument `B` after a named parameter `A` is not a named parameter itself,
+ * `B` is used as value for `A`.
+ * If `A` and `B` are both named parameters, `A` is just treated as a flag (and may receive a default value).
+ * Only named parameters that occur in validFlags are allowed. Specifying named flags that are not listed there
+ * will cause an error.
+ * Named parameters that are either not specified or do not have a value assigned to them may draw a default value
+ * from their definition in validFlags.
+ * @param {string[]} argv - list of command line arguments
+ * @param {import('./typedefs').config.cli.ParameterSchema} schema - allowed flags. May specify default values.
+ * @returns {import('./typedefs').config.cli.ParsedParameters} - parsed arguments
+ */
+const parseCommandlineArgs = (argv, schema) => {
+    const isFlag = (/** @type {string} */ arg) => arg.startsWith('--')
+    const positional = []
+    /** @type {import('./typedefs').config.cli.ParsedParameters['named']} */
+    const named = {}
+
+    let i = 0
+    while (i < argv.length) {
+        const originalArgName = argv[i]  // so our feedback to the user is less confusing
+        let arg = originalArgName
+        if (isFlag(arg)) {
+            arg = camelToSnake(arg.slice(2))
+            // @ts-expect-error - cba to add hasFlag to the general dictionary
+            if (!schema.hasFlag(arg)) {
+                throw new Error(`invalid named flag '${originalArgName}'`)
+            }
+            const next = argv[i + 1]
+            if (next && !isFlag(next)) {
+                named[arg] = { value: next, isDefault: false }
+                i++
+            } else {
+                named[arg] = { value: schema[arg].default, isDefault: true }
+            }
+
+            const { allowed, allowedHint } = schema[arg]
+            if (allowed && !allowed.includes(named[arg].value)) {
+                throw new Error(`invalid value '${named[arg]?.value ?? named[arg]}' for flag ${originalArgName}. Must be one of ${(allowedHint ?? allowed.join(', '))}`)
+            }
+        } else {
+            positional.push(arg)
+        }
+        i++
+    }
+
+    // enrich with defaults
+    /** @type {import('./typedefs').config.cli.ParameterSchema} */
+    const defaults = Object.entries(schema)
+        .filter(e => !!e[1].default)
+        .reduce((dict, [k, v]) => {
+            // @ts-expect-error - can't infer type of initial {}
+            dict[camelToSnake(k)] = { value: v.default, isDefault: true }
+            return dict
+        }, {})
+
+    const namedWithDefaults = {...defaults, ...named}
+
+    // apply postprocessing
+    for (const [key, {value}] of Object.entries(namedWithDefaults)) {
+        const { postprocess } = schema[key]
+        if (typeof postprocess === 'function') {
+            namedWithDefaults[key].value = postprocess(value)
+        }
+    }
+
+    return {
+        named: namedWithDefaults,
+        positional,
+    }
+}
+
+/**
+ * Adds CLI parameters to the configuration object.
+ * Precedence: CLI > env > default.
+ * @param {ReturnType<parseCommandlineArgs>['named']} params - CLI parameters.
+ */
+const addCLIParamsToConfig = params => {
+    for (const [key, value] of Object.entries(params)) {
+        if (!value.isDefault || Object.hasOwn(configuration, key)) {
+            configuration[key] = value.value
+        }
+    }
+}
 
-const flags = {
+const flags = enrichFlagSchema({
     outputDirectory: {
         desc: 'Root directory to write the generated files to.',
         default: './',
@@ -30,16 +157,24 @@ const flags = {
         allowedHint: Object.keys(lls).join(' | '),  // FIXME: remove once old levels are faded out
         defaultHint: _keyFor(lls.ERROR),
         default: cds?.env?.log?.levels?.['cds-typer'] ?? _keyFor(lls.ERROR),
+        postprocess: level => {
+            const newLogLevel = deprecated[level]
+            if (newLogLevel) {
+                console.warn(`deprecated log level '${level}', use '${newLogLevel}' instead (changing this automatically for now).`)
+                return newLogLevel
+            }
+            return level
+        }
     },
     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.`,
-        type: 'string'
+        type: 'string',
+        postprocess: file => file && !file.endsWith('jsconfig.json') ? path.join(file, 'jsconfig.json') : path
     },
-    useEntitiesProxy: {
+    useEntitiesProxy: parameterTypes.boolean({
         desc: `If set to true the 'cds.entities' exports in the generated 'index.js'${EOL}files will be wrapped in 'Proxy' objects\nso static import/require calls can be used everywhere.${EOL}${EOL}WARNING: entity properties can still only be accessed after${EOL}'cds.entities' has been loaded`,
-        allowed: ['true', 'false'],
         default: 'false'
-    },
+    }),
     version: {
         desc: 'Prints the version of this tool.'
     },
@@ -48,17 +183,15 @@ const flags = {
         allowed: ['flat', 'structured'],
         default: 'structured'
     },
-    propertiesOptional: {
+    propertiesOptional: parameterTypes.boolean({
         desc: `If set to true, properties in entities are${EOL}always generated as optional (a?: T).`,
-        allowed: ['true', 'false'],
         default: 'true'
-    },
-    IEEE754Compatible: {
+    }),
+    IEEE754Compatible: parameterTypes.boolean({
         desc: `If set to true, floating point properties are generated${EOL}as IEEE754 compatible '(number | string)' instead of 'number'.`,
-        allowed: ['true', 'false'],
         default: 'false'
-    }
-}
+    })
+})
 
 const hint = () => 'Missing or invalid parameter(s). Call with --help for more details.'
 /**
@@ -74,19 +207,22 @@ const help = () => `SYNOPSIS${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)
+            flags.keys
                 .sort(([a], [b]) => a.localeCompare(b))
-                .map(([key, value]) => {
+                .map(key => {
+                    const value = flags[key]
                     let s = indent(`--${key}`, '  ')
-                    // @ts-expect-error - not going to check presence of each property. Same for the following expect-errors.
+                    const snake = camelToSnake(key)
+                    if (key !== snake) s += EOL + indent(`--${snake}`, '  ')
+                    // ts-expect-error - not going to check presence of each property. Same for the following expect-errors.
                     if (value.allowedHint) s += ` ${value.allowedHint}`
-                    // @ts-expect-error
+                    // ts-expect-error
                     else if (value.allowed) s += `: <${value.allowed.join(' | ')}>`
                     else if ('type' in value && value.type) s += `: <${value.type}>`
-                    // @ts-expect-error
+                    // ts-expect-error
                     if (value.defaultHint || value.default) {
                         s += EOL
-                        // @ts-expect-error
+                        // ts-expect-error
                         s += indent(`(default: ${value.defaultHint ?? value.default})`, '    ')
                     }
                     s += `${EOL2}${indent(value.desc, '    ')}`
@@ -96,7 +232,9 @@ const help = () => `SYNOPSIS${EOL2}` +
 
 const version = () => require('../package.json').version
 
-const main = async (/** @type {any} */ args) => {
+const prepareParameters = (/** @type {any[]} */ argv) => {
+    const args = parseCommandlineArgs(argv, flags)
+
     if ('help' in args.named) {
         console.log(help())
         process.exit(0)
@@ -109,27 +247,21 @@ const main = async (/** @type {any} */ args) => {
         console.log(hint())
         process.exit(1)
     }
-    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: args.named.logLevel,
-        useEntitiesProxy: args.named.useEntitiesProxy === 'true',
-        jsConfigPath: args.named.jsConfigPath,
-        inlineDeclarations: args.named.inlineDeclarations,
-        propertiesOptional: args.named.propertiesOptional === 'true',
-        IEEE754Compatible: args.named.IEEE754Compatible === 'true'
-    })
+    addCLIParamsToConfig(args.named)
+    return args
+}
+
+const main = async (/** @type {any[]} */ argv) => {
+    const { positional } = prepareParameters(argv)
+    compileFromFile(positional)
 }
 
 if (require.main === module) {
-    main(parseCommandlineArgs(process.argv.slice(2), flags))
+    main(process.argv.slice(2))
+}
+
+module.exports = {
+    flags,
+    prepareParameters
 }

package/lib/compile.js

@@ -7,10 +7,7 @@ const util = require('./util')
 const { writeout } = require('./file')
 const { Visitor } = require('./visitor')
 const { LOG, setLevel } = require('./logging')
-
-/**
- * @typedef {import('./typedefs').visitor.CompileParameters} CompileParameters
- */
+const { configuration } = require('./config')
 
 /**
  * Writes the accompanying jsconfig.json file to the specified paths.
@@ -40,31 +37,28 @@ const writeJsConfig = path => {
 /**
  * Compiles a CSN object to Typescript types.
  * @param {{xtended: import('./typedefs').resolver.CSN, inferred: import('./typedefs').resolver.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 }
-    setLevel(parameters.logLevel)
-    if (parameters.jsConfigPath) {
-        writeJsConfig(parameters.jsConfigPath)
+const compileFromCSN = async csn => {
+
+    setLevel(configuration.logLevel)
+    if (configuration.jsConfigPath) {
+        writeJsConfig(configuration.jsConfigPath)
     }
     return writeout(
-        parameters.outputDirectory,
-        Object.values(new Visitor(csn, parameters).getWriteoutFiles())
+        configuration.outputDirectory,
+        Object.values(new Visitor(csn).getWriteoutFiles())
     )
 }
 
 /**
  * Compiles a .cds file to Typescript types.
  * @param {string | string[]} inputFile - path to input .cds file
- * @param {CompileParameters} parameters - path to root directory for all generated files, min log level, etc.
  */
-const compileFromFile = async (inputFile, parameters) => {
+const compileFromFile = async inputFile => {
     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)
+    return compileFromCSN({xtended, inferred})
 }
 
 module.exports = {

package/lib/components/basedefs.js

@@ -13,6 +13,10 @@ const timeRegex = '`${number}${number}:${number}${number}:${number}${number}`'
 const baseDefinitions = new SourceFile('_')
 // FIXME: this should be a library someday
 baseDefinitions.addPreamble(`
+import { type } from '@sap/cds'
+
+export type ElementsOf<T> = {[name in keyof Required<T>]: type }
+
 export namespace Association {
     export type to <T> = T;
     export namespace to {
@@ -38,10 +42,26 @@ export type EntitySet<T> = T[] & {
     data (input:object) : T
 };
 
+export type DraftEntity<T> = T & {
+    IsActiveEntity?: boolean | null
+    HasActiveEntity?: boolean | null
+    HasDraftEntity?: boolean | null
+    DraftAdministrativeData_DraftUUID?: string | null
+}
+
+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]>
 } & Exclude<Required<T>, null>;
 
+const key = Symbol('key')  // to avoid .key showing up in IDE's auto-completion
+export type Key<T> = T & {[key]?: true}
+
+export type KeysOf<T> = {
+  [K in keyof T as NonNullable<T[K]> extends Key<unknown> ? K : never]-?: Key<{}>  // T[K] 
+}
 
 /**
  * Dates and timestamps are strings during runtime, so cds-typer represents them as such.

package/lib/components/class.js

@@ -0,0 +1,35 @@
+/**
+ * Create a class member with given modifiers in the right order.
+ * @param {object} options - options
+ * @param {string} options.name - the name of the member
+ * @param {string} [options.type] - the type of the member
+ * @param {string} [options.initialiser] - the initialiser for the member
+ * @param {string} [options.statementEnd] - the closing character for the member
+ * @param {boolean} [options.isDeclare] - whether the member is declared
+ * @param {boolean} [options.isStatic] - whether the member is static
+ * @param {boolean} [options.isReadonly] - whether the member is readonly
+ * @param {boolean} [options.isOverride] - whether the member is an override
+ */
+function createMember ({name, type = undefined, initialiser = undefined, statementEnd = ';', isDeclare = false,  isStatic = false, isReadonly = false, isOverride = false}) {
+    if (isDeclare && isOverride) throw new Error('member cannot have both declare and override modifiers')
+
+    const parts = []
+
+    if (isDeclare) parts.push('declare')
+    if (isStatic) parts.push('static')
+    if (isOverride) parts.push('override')
+    if (isReadonly) parts.push('readonly')
+
+    parts.push(type ? `${name}: ${type}` : name)
+
+    if (initialiser) parts.push(`= ${initialiser}`)
+
+    const member = parts.join(' ')
+    return statementEnd
+        ? `${member}${statementEnd}`
+        : member
+}
+
+module.exports = {
+    createMember
+}

package/lib/components/enum.js

@@ -55,12 +55,12 @@ const enumVal = (key, value, enumType) => enumType === 'cds.String' ? JSON.strin
 function printEnum(buffer, name, kvs, options = {}, doc=[]) {
     const opts = {...{export: true}, ...options}
     buffer.add('// enum')
-    if (opts.export) doc.forEach(d => { buffer.add(d) })
+    if (opts.export) buffer.add(doc)
     buffer.addIndentedBlock(`${opts.export ? 'export ' : ''}const ${name} = {`, () =>
         kvs.forEach(([k, v]) => { buffer.add(`${normalise(k)}: ${v},`) })
     , '} as const;')
     buffer.add(`${opts.export ? 'export ' : ''}type ${name} = ${stringifyEnumType(kvs)}`)
-    buffer.add('')
+    buffer.blankLine()
 }
 
 /**

package/lib/components/inline.js

@@ -1,8 +1,10 @@
+const { configuration } = require('../config')
 const { SourceFile, Buffer } = require('../file')
 const { normalise } = require('./identifier')
 const { docify } = require('./wrappers')
 
 /** @typedef {import('../resolution/resolver').TypeResolveInfo} TypeResolveInfo */
+/** @typedef {import('../resolution/resolver').TypeResolveOptions} TypeResolverOptions */
 /** @typedef {import('../typedefs').visitor.Inflection} Inflection */
 /** @typedef {import('../typedefs').resolver.PropertyModifier} PropertyModifier */
 /** @typedef {import('../visitor').Visitor} Visitor */
@@ -33,9 +35,10 @@ class InlineDeclarationResolver {
      * @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
+     * @param {TypeResolverOptions} [options] - resolver options
      * @public
      */
-    resolveInlineDeclaration(items, into, relativeTo) {
+    resolveInlineDeclaration(items, into, relativeTo, options) {
         const dummy = new SourceFile(relativeTo.path.asDirectory())
         dummy.classes.currentIndent = relativeTo.classes.currentIndent
         dummy.classes.add('{')
@@ -50,7 +53,9 @@ class InlineDeclarationResolver {
             const se = (typeof subelement === 'string')
                 ? this.visitor.resolver.resolveTypeName(subelement)
                 : subelement
-            into.structuredType[subname] = this.visitor.visitElement(subname, se, dummy)
+            // resolver options need to be passed through, otherwise deep expand of struct types to flat
+            // does not work
+            into.structuredType[subname] = this.visitor.visitElement({name: subname, element: se, file: dummy, resolverOptions: options})
         }
         dummy.classes.outdent()
         dummy.classes.add('}')
@@ -72,14 +77,15 @@ class InlineDeclarationResolver {
      * @param {SourceFile} options.file - the namespace file the surrounding entity is being printed into.
      * @param {Buffer} options.buffer - buffer to add the definition to. If no buffer is passed, the passed file's class buffer is used instead.
      * @param {PropertyModifier[]} options.modifiers - modifiers to add to each generated property
+     * @param {TypeResolverOptions} [options.resolverOptions] - resolver options
      * @public
      */
-    visitElement({name, element, file, buffer = file.classes, modifiers = []}) {
+    visitElement({name, element, file, buffer = file.classes, modifiers = [], resolverOptions}) {
         this.depth++
         for (const d of docify(element.doc)) {
             buffer.add(d)
         }
-        const type = this.visitor.resolver.resolveAndRequire(element, file)
+        const type = this.visitor.resolver.resolveAndRequire(element, file, resolverOptions)
         this.depth--
         if (this.depth === 0) {
             this.printInlineType({fq: name, type, buffer, modifiers})
@@ -94,7 +100,7 @@ class InlineDeclarationResolver {
      * @returns {'?:'|':'}
      */
     getPropertyTypeSeparator() {
-        return this.visitor.options.propertiesOptional ? '?:' : ':'
+        return configuration.propertiesOptional ? '?:' : ':'
     }
 
     /**
@@ -105,7 +111,8 @@ class InlineDeclarationResolver {
      * @public
      */
     getPropertyDatatype(type, typeName = type.typeName) {
-        return type.typeInfo.isNotNull ? typeName : `${typeName} | null`
+        // do not append null if already added to type
+        return type.typeInfo.isNotNull ? typeName : typeName.endsWith('| null') ? typeName : `${typeName} | null`
     }
 
     /**
@@ -267,10 +274,9 @@ class StructuredInlineDeclarationResolver extends InlineDeclarationResolver {
      * @type {InlineDeclarationResolver['printInlineType']}
      */
     printInlineType({fq, type, buffer, modifiers, statementEnd}) {
-        // FIXME: indent not quite right
         const sub = new Buffer()
-        sub.currentIndent = buffer.currentIndent
-        buffer.add(this.flatten({fq, type, buffer: sub, modifiers, statementEnd}).join())
+        this.flatten({fq, type, buffer: sub, modifiers, statementEnd})
+        buffer.add(sub.parts)
     }
 
     /**

package/lib/components/javascript.js

@@ -3,11 +3,11 @@
 // @ts-nocheck
 const proxyAccessFunction = function (fqParts, opts = {}) {
     const { target, customProps } = { target: {}, customProps: [], ...opts }
-    const fq = fqParts.join('.')
+    const fq = fqParts.filter(p => !!p).join('.')
     return new Proxy(target, {
         get: function (target, prop) {
             if (cds.entities) {
-                target.__proto__ = cds.entities[fq]
+                target.__proto__ = cds.entities(fqParts[0])[fqParts[1]]
                 // overwrite/simplify getter after cds.entities is accessible
                 this.get = (target, prop) => target[prop]
                 return target[prop]