@cap-js/cds-typer 0.38.0 → 0.39.0

package/lib/resolution/resolver.js

@@ -11,8 +11,7 @@ const { isEntity, getMaxCardinality, isExternal } = require('../csn')
 const { getBaseDefinitions } = require('../components/basedefs')
 const { BuiltinResolver } = require('./builtin')
 const { LOG } = require('../logging')
-const { last } = require('../components/identifier')
-const { getPropertyModifiers } = require('../components/property')
+const { last, Identifier } = require('../components/identifier')
 const { configuration } = require('../config')
 
 const baseDefinitions = getBaseDefinitions()
@@ -72,7 +71,7 @@ class Resolver {
 
     /**
      * @param {EntityCSN} type - a CSN type
-     * @returns {boolean} whether the type has the @mandatory annotation
+     * @returns {boolean} whether the type has the `@mandatory` annotation
      */
     isMandatory(type) {
         return type['@mandatory'] === true
@@ -214,9 +213,9 @@ class Resolver {
         // guard: types don't get inflected
         if (typeInfo.csn?.kind === 'type') {
             return {
-                singular: typeInfo.plainName,
-                plural: createArrayOf(typeInfo.plainName),
-                typeName: typeInfo.plainName,
+                singular: new Identifier(typeInfo.plainName),
+                plural: new Identifier(createArrayOf(typeInfo.plainName)),
+                typeName: typeInfo.plainName
             }
         }
 
@@ -238,19 +237,46 @@ class Resolver {
             // FIXME: in most other places where we have an inline declaration, we actually don't need the typeName.
             // 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()
-            this.structuredInlineResolver.printInlineType({
-                fq: '',
-                type: { typeInfo, typeName: '' },
-                buffer: into,
-                statementEnd: '',
-                modifiers: getPropertyModifiers(typeInfo.csn)
-            })
-            typeName = into.join()
+
+            // If the inline type has a structuredType, print it properly.
+            // Otherwise, just use the type string directly (e.g., '{}' for empty inline types)
+            if (typeInfo.structuredType) {
+                const into = new Buffer()
+                // For action/function return types, the inline type itself should not have | null appended
+                // Nullability is handled at the action level, not within the inline type
+                const typeInfoWithNotNull = { ...typeInfo, isNotNull: true }
+                this.structuredInlineResolver.printInlineType({
+                    fq: '',
+                    type: { typeInfo: typeInfoWithNotNull, typeName: '' },
+                    buffer: into,
+                    statementEnd: '',
+                    modifiers: []  // No modifiers for inline types in type positions (function params/returns)
+                })
+                // Join with space instead of newline for inline types so they can be used in type parameters
+                typeName = into.join(' ')
+            } else {
+                // No structured type (e.g., empty inline declaration like `element.type === undefined`)
+                // Just use the type string directly
+                typeName = typeInfo.type
+            }
             singular = typeName
-            plural = createArrayOf(typeName)
+            // For inline types, plural is the same as singular - the wrapper (Composition.of.many, etc.)
+            // handles the array semantics, so we don't need to wrap in Array<> here
+            plural = typeName
+            // Create Identifier instances for inline types to maintain API consistency
+            // We mark them as "already normalized" to prevent the Identifier constructor from
+            // parsing dots or attempting normalization on TypeScript type literal strings
+            // By passing a fake 'from' object with the same plain value, we ensure:
+            // - .normalised returns the same instance (no further normalization)
+            // - .isChangedFromNormalisation returns false
+            // - Dot-parsing is skipped (scope is explicitly provided as [])
+            const createInlineIdentifier = (/** @type {string} */typeString) => new Identifier(typeString, [], null, true)
+            return {
+                typeName,
+                singular: createInlineIdentifier(singular),
+                plural: createInlineIdentifier(plural)
+            }
         } 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)
@@ -272,7 +298,7 @@ class Resolver {
             LOG.error(`Singular ('${singular}') or plural ('${plural}') for '${typeName}' is empty.`)
         }
 
-        return { typeName, singular, plural }
+        return { typeName, singular: new Identifier(singular), plural: new Identifier(plural) }
     }
 
     /**
@@ -300,18 +326,32 @@ class Resolver {
 
         /** @type {string|undefined} */
         let typeNamespaceIdent = undefined
-        let typeName = typeInfo.plainName ?? typeInfo.type
+        // For inline declarations, we use the plain type string without normalization
+        // because it's a TypeScript type literal, not an identifier
+        let typeName = typeInfo.isInlineDeclaration
+            ? (typeInfo.inflection?.singular.plain ?? typeInfo.type)
+            : (typeInfo.inflection?.singular.normalised.plain ?? typeInfo.plainName ?? typeInfo.type)
 
         // only applies to builtin types, because the association/ composition _themselves_ are the (builtin) types we are checking, not their generic parameter!
         if (typeInfo.isBuiltin === true) {
-            const [toOne, toMany] =
-                {
-                    Association: [createToOneAssociation, createToManyAssociation],
-                    Composition: [createCompositionOfOne, createCompositionOfMany],
-                    array: [createArrayOf, createArrayOf]
-                }[element.constructor.name] ?? []
-
-            if (toOne && toMany) {
+            // Handle regular arrays (array of Type)
+            if (typeInfo.isArray === true && typeInfo.itemsType) {
+                // Array items should not be nullable - the array itself handles nullability
+                // @ts-expect-error - yes, we know that notNull is not part of the type in some cases
+                element.items.notNull = true
+                // Recursively resolve the items type
+                const itemsTypeResolved = this.resolveAndRequire(element.items, file, options)
+                // Use the resolved items type name
+                typeName = createArrayOf(itemsTypeResolved.typeName)
+            } else {
+                const [toOne, toMany] =
+                    {
+                        Association: [createToOneAssociation, createToManyAssociation],
+                        Composition: [createCompositionOfOne, createCompositionOfMany],
+                        array: [createArrayOf, createArrayOf]
+                    }[element.constructor.name] ?? []
+
+                if (toOne && toMany) {
                 /**
                  * Resolve a property from a CSN entity. If it is a reference, leave it as is.
                  * If it is a string, return an object with type set to the string.
@@ -319,31 +359,57 @@ class Resolver {
                  * @param {string} property - the property to check
                  * @returns {import('../typedefs').resolver.EntityCSN | { type: string }}
                  */
-                const getTarget = (el, property) => typeof el[property] === 'string'
-                    ? { type: el[property] }
-                    : el[property]
+                    const getTarget = (el, property) => typeof el[property] === 'string'
+                        ? { type: el[property] }
+                        : el[property]
 
-                /** @type { EntityCSN | { type: string } | undefined } */
-                const target = element.items
+                    /** @type { EntityCSN | { type: string } | undefined } */
+                    const target = element.items
                     ?? getTarget(element, 'target')
                     ?? getTarget(element, 'targetAspect')  // Composition of aspects
-                if (!target) {
-                    throw new Error(`Could not resolve target of ${element}`)
-                }
-                /** set `notNull = true` to avoid repeated `| not null` TS construction */
-                // @ts-expect-error - yes, we know that notNull is not part of the type in some cases
-                target.notNull = true
-                // @ts-expect-error - yes, target is a valid parameter
-                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
-
-                    typeName = cardinality > 1
-                        ? toMany(plural)
-                        : toOne(this.visitor.isSelfReference(target) ? 'this' : singular)
-                    file.addImport(baseDefinitions.path)
+                    if (!target) {
+                        throw new Error(`Could not resolve target of ${element}`)
+                    }
+                    /** set `notNull = true` to avoid repeated `| not null` TS construction */
+                    // @ts-expect-error - yes, we know that notNull is not part of the type in some cases
+                    target.notNull = true
+                    // @ts-expect-error - yes, target is a valid parameter
+                    const targetTypeInfo = this.resolveAndRequire(target, file)
+                    if (targetTypeInfo.typeInfo.isDeepRequire === true) {
+                    //typeName = cardinality > 1 ? toMany(targetTypeInfo.typeName) : toOne(targetTypeInfo.typeName)
+                    //FIXME: do we ned this change as opposed to line above?
+                    // For inline declarations, use plain type without normalization but wrap in Array for many cardinality
+                        let targetTypeName = targetTypeInfo.typeInfo.isInlineDeclaration
+                            ? targetTypeInfo.typeInfo.inflection.singular.plain
+                            : targetTypeInfo.typeInfo.inflection.singular.normalised.plain
+                        // Inline types need to be wrapped in Array<> for many cardinality since they're struct types
+                        if (targetTypeInfo.typeInfo.isInlineDeclaration && cardinality > 1) {
+                            targetTypeName = createArrayOf(targetTypeName)
+                        }
+                        typeName = cardinality > 1
+                            ? toMany(targetTypeName)
+                            : toOne(targetTypeName)
+                    } else {
+                        let { singular, plural } = targetTypeInfo.typeInfo.inflection
+                        // For inline declarations, use plain type without normalization
+                        // Note: This code path may be unreachable as inline compositions/associations are
+                        // extracted to named classes by the visitor before type resolution occurs.
+                        if (targetTypeInfo.typeInfo.isInlineDeclaration) {
+                            // For inline struct types, we need to wrap in Array<> for many cardinality
+                            let inlineType = singular.plain
+                            if (cardinality > 1) {
+                                inlineType = createArrayOf(inlineType)
+                            }
+                            typeName = cardinality > 1
+                                ? toMany(inlineType)
+                                : toOne(this.visitor.isSelfReference(target) ? 'this' : inlineType)
+                        } else {
+                            typeName = cardinality > 1
+                                ? toMany(plural.normalised.scoped)
+                                : toOne(this.visitor.isSelfReference(target) ? 'this' : singular.normalised.scoped)
+                        }
+                        file.addImport(baseDefinitions.path)
+                    }
                 }
             }
         } else {
@@ -355,19 +421,24 @@ class Resolver {
                 const parent = new Path(namespace.split('.')) //t.path.getParent()
                 typeInfo.inflection = this.inflect(typeInfo, namespace)
 
+                // Update typeName to use the normalized identifier
+                // This is important for delimited identifiers that get normalized (e.g., "T Y P E" -> "__T_Y_P_E")
+                typeName = typeInfo.inflection.singular.normalised.plain
+
                 if (!parent.isCwd(file.path.asDirectory())) {
                     file.addImport(parent)
                     // prepend namespace
                     typeNamespaceIdent = parent.asIdentifier()
                     typeName = [typeNamespaceIdent, typeName].join('.')
-                    typeInfo.inflection.singular = [typeNamespaceIdent, typeInfo.inflection.singular].join('.')
-                    typeInfo.inflection.plural = [typeNamespaceIdent, typeInfo.inflection.plural].join('.')
+                    typeInfo.inflection.singular = new Identifier(typeInfo.inflection.singular.plain, [typeNamespaceIdent])
+                    typeInfo.inflection.plural = new Identifier(typeInfo.inflection.plural.plain, [typeNamespaceIdent])
                 }
 
-                if (element.type.ref?.length > 1) {
+                if (typeof element.type !== 'string' && element.type.ref?.length > 1) {
                     const [, ...members] = element.type.ref
                     const lookup = this.visitor.inlineDeclarationResolver.getTypeLookup(members)
-                    typeName = deepRequire(typeInfo.inflection.singular, lookup)
+                    // Use normalised.scoped to include namespace prefix (e.g., _.managed instead of managed)
+                    typeName = deepRequire(typeInfo.inflection.singular.normalised.scoped, lookup)
                     typeInfo.isDeepRequire = true
                     file.addImport(baseDefinitions.path)
                 }
@@ -383,10 +454,34 @@ class Resolver {
 
         if (typeInfo.isInlineDeclaration === true) {
             typeInfo.inflection = this.inflect(typeInfo)
+
+            // Handle inline enums that originate from a different entity's namespace
+            // (e.g., foreign keys from associations to entities with inline enum keys)
+            // In such cases, we need to import the namespace and prepend the identifier
+            const targetEntity = element._targetEntity
+            if (targetEntity) {
+                const namespace = this.resolveNamespace(targetEntity)
+                const parent = new Path(namespace.split('.'))
+
+                if (!parent.isCwd(file.path.asDirectory())) {
+                    // Add import for the target entity's namespace
+                    file.addImport(parent)
+                    const parentNamespaceIdent = parent.asIdentifier()
+
+                    // Update typeName to include the namespace
+                    typeName = [parentNamespaceIdent, typeName].filter(Boolean).join('.')
+                    typeInfo.inflection.singular = [parentNamespaceIdent, typeInfo.inflection.singular].filter(Boolean).join('.')
+                    typeInfo.inflection.plural = [parentNamespaceIdent, typeInfo.inflection.plural].filter(Boolean).join('.')
+                }
+            } else {
+                // Update typeName from the inflection for inline types
+                typeName = typeInfo.inflection.typeName
+            }
         }
 
         // handle typeof (unless it has already been handled above)
-        const target = element.target?.name ?? element.type?.ref?.join('.') ?? element.type
+        // @ts-expect-error - TS disliked optional chaining of ?.ref on (ref | string), but is valid here
+        const target = element.target ?? element.type?.ref?.join('.') ?? element.type
         if (target && !typeInfo.isDeepRequire) {
             const { propertyAccess, scope } = this.visitor.entityRepository.getByFq(target) ?? {}
             if (scope?.length && typeInfo.inflection) {
@@ -394,23 +489,72 @@ class Resolver {
                 // remove already added namespace, so the scope is added after the namespace
                 // i.e. _common.Book.texts instead of Book._common.texts
                 if (typeNamespaceIdent) {
-                    if (singular.startsWith(typeNamespaceIdent)) {
-                        singular = singular.substring(typeNamespaceIdent.length+1)
+                    if (singular.plain.startsWith(typeNamespaceIdent)) {
+                        singular.plain = singular.plain.substring(typeNamespaceIdent.length+1)
                     }
-                    if (plural.startsWith(typeNamespaceIdent)) {
-                        plural = plural.substring(typeNamespaceIdent.length+1)
+                    if (plural.plain.startsWith(typeNamespaceIdent)) {
+                        plural.plain = plural.plain.substring(typeNamespaceIdent.length+1)
                     }
                 }
                 // update inflections with proper prefix, e.g. Books.text, Books.texts
                 typeInfo.inflection = {
-                    singular: [typeNamespaceIdent, ...scope, singular].filter(Boolean).join('.'),
-                    plural: [typeNamespaceIdent,...scope, plural].filter(Boolean).join('.')
+                    singular: new Identifier(singular, /** @type {string[]} */([typeNamespaceIdent, ...scope].filter(Boolean))),
+                    plural: new Identifier(plural, /** @type {string[]} */([typeNamespaceIdent, ...scope].filter(Boolean)))
                 }
             } else if (propertyAccess?.length) {
                 const element = target.slice(0, -propertyAccess.join('.').length - 1)
                 const access = this.visitor.inlineDeclarationResolver.getTypeLookup(propertyAccess)
+                // Get the entity info to determine the proper namespace
+                const elementInfo = this.visitor.entityRepository.getByFq(element)
+                let elementName
+                LOG.debug(`propertyAccess: element=${element}, hasInfo=${!!elementInfo}`)
+                if (elementInfo) {
+                    // Check if the element is from the same file or needs an import
+                    const elementNamespace = this.resolveNamespace(elementInfo.namespace.parts)
+                    const elementParent = new Path(elementNamespace.split('.'))
+                    const elementInflection = this.inflect({
+                        csn: elementInfo.csn,
+                        plainName: elementInfo.withoutNamespace
+                    }, elementNamespace)
+
+                    LOG.debug(`propertyAccess with info: elementNamespace=${elementNamespace}, file=${file.path.asDirectory()}, isCwd=${elementParent.isCwd(file.path.asDirectory())}`)
+
+                    if (!elementParent.isCwd(file.path.asDirectory())) {
+                        // Different file - add import and namespace prefix
+                        file.addImport(elementParent)
+                        elementName = `${elementParent.asIdentifier()}.${elementInflection.singular.normalised.plain}`
+                    } else {
+                        // Same file - use normalized name with scope if needed
+                        elementName = elementInflection.singular.normalised.plain
+                    }
+                } else {
+                    // Fallback: check if element is in CSN and determine its namespace
+                    const elementCsn = this.csn.definitions[element]
+                    LOG.debug(`propertyAccess fallback: elementCsn=${!!elementCsn}`)
+                    if (elementCsn) {
+                        // Element exists in CSN, determine its namespace
+                        const elementFqParts = element.split('.')
+                        const elementNs = elementFqParts.slice(0, -1).join('.')
+                        const currentFileNs = file.path.parts.join('.')
+
+                        LOG.debug(`propertyAccess CSN: elementNs='${elementNs}', currentFileNs='${currentFileNs}'`)
+
+                        if (elementNs !== currentFileNs) {
+                            // Different namespace - need prefix
+                            const elementParent = new Path(elementNs.split('.').filter(Boolean))
+                            file.addImport(elementParent)
+                            elementName = `${elementParent.asIdentifier()}.${new Identifier(util.singular4(element)).normalised.plain}`
+                        } else {
+                            // Same namespace
+                            elementName = new Identifier(util.singular4(element)).normalised.plain
+                        }
+                    } else {
+                        // Element not in CSN, just normalize
+                        elementName = new Identifier(util.singular4(element)).normalised.plain
+                    }
+                }
                 // singular, as we have to access the property of the entity
-                typeName = deepRequire(util.singular4(element)) + access
+                typeName = deepRequire(elementName) + access
                 typeInfo.isDeepRequire = true
             }
         }
@@ -418,8 +562,8 @@ class Resolver {
         // add fallback inflection. Mainly needed for array-of with builtin types.
         // (array-of relies on inflection being present, which is not the case in builtin)
         typeInfo.inflection ??= {
-            singular: typeName,
-            plural: typeName
+            singular: new Identifier(typeName),
+            plural: new Identifier(typeName)
         }
 
         if (element.key === true) {
@@ -427,7 +571,10 @@ class Resolver {
         }
 
         // FIXME: typeName could probably just become part of typeInfo
-        return { typeName, typeInfo }
+        return /** @type {ResolveAndRequireInfo}*/({  // can cast, as we gave an .inflection above
+            typeName,
+            typeInfo
+        })
     }
 
     /**
@@ -479,7 +626,7 @@ class Resolver {
         // with an already resolved type. In that case, just return the type we have.
         // type guard check purely to satisfy return statement
         /**
-         * @param {any} e - the element to check
+         * @param {unknown} e - the element to check
          * @returns {e is TypeResolveInfo}
          */
         const isBuiltin = e => Object.hasOwn(e ?? {}, 'isBuiltin')
@@ -487,6 +634,8 @@ class Resolver {
 
         const cardinality = getMaxCardinality(element)
 
+        // FIXME while it may be tempting to add the missing plainName here, we do have "typename ?? ..."
+        // expressions which will then fail. We should instead use a more reliable way to determine plainName later on.
         /** @type {TypeResolveInfo} */
         const result = {
             isBuiltin: false, // will be rectified in the corresponding handlers, if needed
@@ -503,9 +652,10 @@ class Resolver {
         result.isNotNull ||= element.kind === 'param' && this.isMandatory(element)
 
 
-        if (element?.type === undefined) {
+        if (element?.type === undefined && !element?.items) {
             // "fallback" type "empty object". May be overriden via #resolveInlineDeclarationType
             // later on with an inline declaration
+            // NOTE: Arrays have no type property, only items, so we exclude them here
             result.type = '{}'
             result.isInlineDeclaration = true
         } else if (!isReferenceType(element) && isInlineEnumType(element, this.csn)) {
@@ -523,8 +673,10 @@ class Resolver {
                 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)
+                // Normalize both entity and property names to handle delimited identifiers
+                const cleanEntityName = new Identifier(util.singular4(element.parent, true)).normalised.plain
+                const cleanPropertyName = new Identifier(element.name).normalised.plain
+                const enumName = propertyToInlineEnumName(cleanEntityName, cleanPropertyName)
                 result.type = enumName
                 result.plainName = enumName
             } else {
@@ -537,7 +689,8 @@ class Resolver {
                 // stringifyEnumType(csnToEnumPairs(element))
                 this.resolveTypeName(element.type, result)
             }
-        } else {
+        } else if (element?.type !== undefined) {
+            // Only resolve the type if it exists (not an array or empty inline declaration)
             this.resolvePotentialReferenceType(element.type, result, file)
         }
 
@@ -547,7 +700,7 @@ class Resolver {
             // TODO: re-implement this line once {element.notNull} will be provided for array-like elements
             result.isNotNull = true
             result.isBuiltin = true
-            this.resolveType(element.items, file)
+            result.itemsType = this.resolveType(element.items, file)
             //delete element.items
         } else if (!result.isBuiltin && !isExternal(element) && element?.elements && (options?.forceInlineStructs || !element?.type)) {
             // explicitly skip named type definitions, which have elements too, but should not be considered inline declarations
@@ -567,14 +720,16 @@ class Resolver {
      * Resolves an inline declaration of a type.
      * We can encounter declarations like:
      *
+     * ```
      * record : array of {
      * column : String;
      * data   : String;
      * }
+     * ```
      *
      * These have to be resolved to a new type.
      * @param {{ [key: string]: EntityCSN }} items - the properties of the inline declaration.
-     * @param {TypeResolveInfo} into - @see resolveType()
+     * @param {TypeResolveInfo} into - {@link resolveType}
      * @param {SourceFile} relativeTo - the sourcefile in which we have found the reference to the type.
      * @param {TypeResolveOptions} [options] - resolver options
      *  This is important to correctly detect when a field in the inline declaration is referencing
@@ -591,7 +746,6 @@ class Resolver {
      * @param {SourceFile} file - only needed as we may call #resolveInlineDeclarationType from here. Will be expelled at some point.
      */
     resolvePotentialReferenceType(val, into, file) {
-        // FIXME: get rid of file parameter! it is only used to pass to #resolveInlineDeclarationType
         if (val.elements) {
             this.#resolveInlineDeclarationType(val, into, file) // FIXME INDENT!
         } else if (val.constructor === Object && 'ref' in val) {
@@ -607,11 +761,12 @@ class Resolver {
      * Attempts to resolve a string to a type.
      * String is supposed to refer to either a builtin type
      * or any type defined in CSN.
-     * @param {string} t - fully qualified type, like cds.String, or a.b.c.d.Foo
+     * @param {Identifier | string} t - fully qualified type, like cds.String, or a.b.c.d.Foo
      * @param {TypeResolveInfo} [into] - optional dictionary to fill by reference, see resolveType()
-     * @returns @see resolveType
+     * @returns {ReturnType<Resolver['resolveType']>}
      */
     resolveTypeName(t, into) {
+        if (typeof t !== 'string') t = t.plain
         const result = into ?? /** @type {TypeResolveInfo} */({})
         const path = t.split('.')
         const builtin = this.builtinResolver.resolveBuiltin(path)

package/lib/typedefs.d.ts

@@ -1,3 +1,5 @@
+import type { Identifier } from './components/identifier'
+
 export module resolver {
     type ref = {
         ref: string[],
@@ -31,6 +33,7 @@ export module resolver {
         '@odata.draft.enabled'?: boolean // custom!
         _unresolved?: boolean
         isRefNotNull?: boolean // custom!
+        _targetEntity?: string // custom! Name of the target entity when this element is a composition or association
     }
 
     export type OperationCSN = EntityCSN & {
@@ -95,9 +98,9 @@ export module resolver {
          *
          * They only exist in the original defined form in the CSN and LinkedCSN but not in the compiled
          * OData or SQL models (i.e. `cds.compile(..).for.odata()`).
-         * 
+         *
          * Therefore they need to be flattened down like inline structs.
-         * 
+         *
          * ```cds
          * // model.cds
          * type Adress {
@@ -109,12 +112,12 @@ export module resolver {
          *   address: Adress
          * }
          * ```
-         * 
+         *
          * // service.js
          * ```js
          * const {title, address_street, address_zipCode} = await SELECT.from(Persons);
          * ```
-         * 
+         *
          */
         forceInlineStructs?: boolean
     }
@@ -145,12 +148,12 @@ export module util {
 export module visitor {
     export type Inflection = {
         typeName?: string,
-        singular: string,
-        plural: string
+        singular: Identifier,
+        plural: Identifier
     }
 
     export type Context = {
-        entity: string
+        entity: Identifier
     }
 
     export type ParamInfo = {
@@ -213,6 +216,8 @@ export module config {
          * `legacyBinaryTypes = true` -> Binary and LargeBinary are generated as `string` and a union type respectively
          */
         legacyBinaryTypes: boolean
+        /** `brandedPrimitiveTypes = true` -> all generated primitive types will be branded */
+        brandedPrimitiveTypes: boolean
     }
 }
 

package/lib/util.js

@@ -3,6 +3,7 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
+const { LOG } = require('./logging')
 
 // inflection functions are stolen from github/cap/dev/blob/main/etc/inflect.js
 
@@ -13,7 +14,7 @@ if (process.version.startsWith('v14')) {
     Object.hasOwn = Object.hasOwn ?? ((obj, attr) => Boolean(obj && obj.hasOwnProperty(attr)))
 }
 
-const last = /\w+$/
+const last = /[^.]+$/
 
 const annotations = /** @type {const} */ ({
     singular: ['@singular'],
@@ -61,9 +62,10 @@ const getPluralAnnotation = csn => csn[annotations.plural.find(a => Object.hasOw
  * unlocalize("{i18n>Foo}") -> "Foo"
  * @param {string} name - the entity name (singular or plural).
  * @returns {string} the name without localisation syntax or untouched.
- * @deprecated we have dropped this feature altogether, users specify custom names via @singular/@plural now
+ * @deprecated we have dropped this feature altogether, users specify custom names via  `@singular`/`@plural` now
  */
 const unlocalize = name => {
+    LOG.warn('util.unlocalize is deprecated and will be removed in future versions.')
     const match = name.match(/\{i18n>(.*)\}/)
     return match ? match[1] : name
 }