@cap-js/cds-typer 0.22.0 → 0.24.0

package/lib/visitor.js

@@ -2,17 +2,19 @@
 
 const util = require('./util')
 
-const { amendCSN, isView, isUnresolved, propagateForeignKeys, isDraftEnabled, isType, isProjection } = require('./csn')
+const { amendCSN, isView, isUnresolved, propagateForeignKeys, isDraftEnabled, isType, isProjection, getMaxCardinality } = require('./csn')
 // eslint-disable-next-line no-unused-vars
 const { SourceFile, FileRepository, Buffer } = require('./file')
 const { FlatInlineDeclarationResolver, StructuredInlineDeclarationResolver } = require('./components/inline')
-const { Resolver } = require('./components/resolver')
-const { Logger } = require('./logging')
+const { Resolver } = require('./resolution/resolver')
+const { LOG } = require('./logging')
 const { docify } = require('./components/wrappers')
 const { csnToEnumPairs, propertyToInlineEnumName, isInlineEnumType, stringifyEnumType } = require('./components/enum')
 const { isReferenceType } = require('./components/reference')
 const { empty } = require('./components/typescript')
 const { baseDefinitions } = require('./components/basedefs')
+const { EntityRepository } = require('./resolution/entity')
+const { last } = require('./components/identifier')
 
 /** @typedef {import('./file').File} File */
 /** @typedef {import('./typedefs').visitor.Context} Context */
@@ -39,14 +41,12 @@ class Visitor {
 
     /**
      * @param {{xtended: CSN, inferred: CSN}} csn - root CSN
-     * @param {VisitorOptions} options
-     * @param {Logger} logger
+     * @param {VisitorOptions} options - the options
      */
-    constructor(csn, options = {}, logger = new Logger()) {
+    constructor(csn, options = {}) {
         amendCSN(csn.xtended)
         propagateForeignKeys(csn.inferred)
         this.options = { ...defaults, ...options }
-        this.logger = logger
         this.csn = csn
 
         /** @type {Context[]} **/
@@ -55,6 +55,9 @@ class Visitor {
         /** @type {Resolver} */
         this.resolver = new Resolver(this)
 
+        /** @type {EntityRepository} */
+        this.entityRepository = new EntityRepository(this.resolver)
+
         /** @type {FileRepository} */
         this.fileRepository = new FileRepository()
         this.fileRepository.add(baseDefinitions.path.asNamespace(), baseDefinitions)
@@ -76,7 +79,7 @@ class Visitor {
             } else if (isProjection(entity) || !isUnresolved(entity)) {
                 this.visitEntity(name, entity)
             } else {
-                this.logger.warning(`Skipping unresolved entity: ${name}`)
+                LOG.warn(`Skipping unresolved entity: ${name}`)
             }
         }
         // FIXME: optimise
@@ -91,13 +94,13 @@ class Visitor {
             // instead of using the definition from inferred CSN, we refer to the projected entity from xtended CSN instead.
             // The latter contains the CSN fixes (propagated foreign keys, etc) and none of the localised fields we don't handle yet.
             if (entity.projection) {
-                const targetName = entity.projection.from.ref[0] 
+                const targetName = entity.projection.from.ref[0]
                 // FIXME: references to types of entity properties may be missing from xtendend flavour (see #103)
                 // this should be revisted once we settle on a single flavour.
                 const target = this.csn.xtended.definitions[targetName] ?? this.csn.inferred.definitions[targetName]
                 this.visitEntity(name, target)
             } else {
-                this.logger.error(`Expecting an autoexposed projection within a service. Skipping ${name}`)
+                LOG.error(`Expecting an autoexposed projection within a service. Skipping ${name}`)
             }
         }
     }
@@ -105,10 +108,10 @@ class Visitor {
     /**
      * Retrieves all the keys from an entity.
      * That is: all keys that are present in both inferred, as well as xtended flavour.
-     * @param {string} name
+     * @param {string} fq - fully qualified name of the entity
      * @returns {[string, object][]} array of key name and key element pairs
      */
-    #keys(name) {
+    #keys(fq) {
         // FIXME: this is actually pretty bad, as not only have to propagate keys through
         // both flavours of CSN (see constructor), but we are now also collecting them from
         // both flavours and deduplicating them.
@@ -116,8 +119,8 @@ class Visitor {
         // inferred contains keys from queried entities (thing `entity Foo as select from Bar`, where Bar has keys)
         // So we currently need them both.
         return Object.entries({
-            ...this.csn.inferred.definitions[name]?.keys ?? {},
-            ...this.csn.xtended.definitions[name]?.keys ?? {}
+            ...this.csn.inferred.definitions[fq]?.keys ?? {},
+            ...this.csn.xtended.definitions[fq]?.keys ?? {}
         })
     }
 
@@ -127,27 +130,47 @@ class Visitor {
      * - the function A(B) to mix the aspect into another class B
      * - the const AXtended which represents the entity A with all of its aspects mixed in (this const is not exported)
      * - the type A to use for external typing and is derived from AXtended.
-     * @param {string} name - the name of the entity
+     * @param {string} fq - the name of the entity
      * @param {CSN} entity - the pointer into the CSN to extract the elements from
      * @param {Buffer} buffer - the buffer to write the resulting definitions into
-     * @param {{cleanName?: string}} options
+     * @param {{cleanName?: string}} options - additional options
      */
-    #aspectify(name, entity, buffer, options = {}) {
-        const clean = options?.cleanName ?? this.resolver.trimNamespace(name)
-        const namespace = this.resolver.resolveNamespace(name.split('.'))
+    #aspectify(fq, entity, buffer, options = {}) {
+        const info = this.entityRepository.getByFq(fq)
+        const clean = options?.cleanName ?? info.withoutNamespace
+        const { namespace } = info
         const file = this.fileRepository.getNamespaceFile(namespace)
         const identSingular = name => name
         const identAspect = name => `_${name}Aspect`
+        const toAspectIdent = (wrapped, [ns, n, fq]) => {
+            // types are not inflected, so don't change those to singular
+            const refersToType = isType(this.csn.inferred.definitions[fq])
+            const ident = identAspect(refersToType 
+                ? n 
+                : this.resolver.inflect({csn: this.csn.inferred.definitions[fq], plainName: n}).singular
+            )
+            return !ns || ns.isCwd(file.path.asDirectory())
+                ? `${ident}(${wrapped})`
+                : `${ns.asIdentifier()}.${ident}(${wrapped})` 
+        }
+        const ancestors = (entity.includes ?? [])
+            .map(parent => {
+                const { namespace, entityName } = this.entityRepository.getByFq(parent)
+                file.addImport(namespace)
+                return [namespace, entityName, parent]
+            })
+            .reverse() // reverse so that own aspect A is applied before extensions B,C: B(C(A(Entity)))
+            .reduce(toAspectIdent, 'Base')
 
-        this.contexts.push({ entity: name })
+        this.contexts.push({ entity: fq })
 
         // CLASS ASPECT
-        buffer.addIndentedBlock(`export function ${identAspect(clean)}<TBase extends new (...args: any[]) => object>(Base: TBase) {`, function () {
-            buffer.addIndentedBlock(`return class ${clean} extends Base {`, function () {
+        buffer.addIndentedBlock(`export function ${identAspect(clean)}<TBase extends new (...args: any[]) => object>(Base: TBase) {`, () => {
+            buffer.addIndentedBlock(`return class ${clean} extends ${ancestors} {`, () => {
                 const enums = []
                 for (let [ename, element] of Object.entries(entity.elements ?? {})) {
                     if (element.target && /\.texts?/.test(element.target)) {
-                        this.logger.warning(`referring to .texts property in ${name}. This is currently not supported and will be ignored.`)
+                        LOG.warn(`referring to .texts property in ${fq}. This is currently not supported and will be ignored.`)
                         continue
                     }
                     this.visitElement(ename, element, file, buffer)
@@ -158,13 +181,13 @@ class Visitor {
                         // We don't really have to care for this case, as keys from such structs are _not_ propagated to
                         // the containing entity.
                         for (const [kname, originalKeyElement] of this.#keys(element.target)) {
-                            if (this.resolver.getMaxCardinality(element) === 1 && typeof element.on !== 'object') {  // FIXME: kelement?
+                            if (getMaxCardinality(element) === 1 && typeof element.on !== 'object') {  // FIXME: kelement?
                                 const foreignKey = `${ename}_${kname}`
                                 if (Object.hasOwn(entity.elements, foreignKey)) {
-                                    this.logger.error(`Attempting to generate a foreign key reference called '${foreignKey}' in type definition for entity ${name}. But a property of that name is already defined explicitly. Consider renaming that property.`)
+                                    LOG.error(`Attempting to generate a foreign key reference called '${foreignKey}' in type definition for entity ${fq}. But a property of that name is already defined explicitly. Consider renaming that property.`)
                                 } else {
-                                    const kelement = Object.assign(Object.create(originalKeyElement), { 
-                                        isRefNotNull: !!element.notNull || !!element.key 
+                                    const kelement = Object.assign(Object.create(originalKeyElement), {
+                                        isRefNotNull: !!element.notNull || !!element.key
                                     })
                                     this.visitElement(foreignKey, kelement, file, buffer)
                                 }
@@ -178,14 +201,14 @@ class Visitor {
                     }
                 }
 
-                buffer.addIndented(function() {
+                buffer.addIndented(() => {
                     for (const e of enums) {
                         buffer.add(`static ${e.name} = ${propertyToInlineEnumName(clean, e.name)}`)
-                        file.addInlineEnum(clean, name, e.name, csnToEnumPairs(e, {unwrapVals: true}))
+                        file.addInlineEnum(clean, fq, e.name, csnToEnumPairs(e, {unwrapVals: true}))
                     }
                     const actions = Object.entries(entity.actions ?? {})
                     if (actions.length) {
-                        buffer.addIndentedBlock('static readonly actions: {', 
+                        buffer.addIndentedBlock('static readonly actions: {',
                             actions.map(([aname, action]) => SourceFile.stringifyLambda({
                                 name: aname,
                                 parameters: this.#stringifyFunctionParams(action.params, file),
@@ -196,37 +219,13 @@ class Visitor {
                     } else {
                         buffer.add(`static readonly actions: ${empty}`)
                     }
-                }.bind(this))
-            }.bind(this), '};') // end of generated class
-        }.bind(this), '}') // end of aspect
+                })
+            }, '};') // end of generated class
+        }, '}') // end of aspect
 
         // CLASS WITH ADDED ASPECTS
         file.addImport(baseDefinitions.path)
-        const ancestors = (entity.includes ?? [])
-            .map(parent => {
-                const { namespace, name } = this.resolver.untangle(parent)
-                file.addImport(namespace)
-                return [namespace, name, parent]
-            })
-            .concat([[undefined, clean, name]]) // add own aspect without namespace AFTER imports were created
-            //.concat([[undefined, clean, [namespace, clean].filter(Boolean).join('.')]]) // add own aspect without namespace AFTER imports were created
-            .reverse() // reverse so that own aspect A is applied before extensions B,C: B(C(A(Entity)))
-            .reduce((wrapped, [ns, n, fq]) => {
-                // types are not inflected, so don't change those to singular
-                const refersToType = isType(this.csn.inferred.definitions[fq])
-                const ident = identAspect(refersToType 
-                    ? n 
-                    : this.resolver.inflect({csn: this.csn.inferred.definitions[fq], plainName: n}).singular
-                )
-                return !ns || ns.isCwd(file.path.asDirectory())
-                    ? `${ident}(${wrapped})`
-                    : `${ns.asIdentifier()}.${ident}(${wrapped})` 
-            },
-            `${baseDefinitions.path.asIdentifier()}.Entity`
-            )
-
-        buffer.add(`export class ${identSingular(clean)} extends ${ancestors} {${this.#staticClassContents(clean, entity).join('\n')}}`)
-        //buffer.add(`export type ${clean} = InstanceType<typeof ${identSingular(clean)}>`)
+        buffer.add(`export class ${identSingular(clean)} extends ${toAspectIdent(`${baseDefinitions.path.asIdentifier()}.Entity`, [undefined, clean, fq])} {${this.#staticClassContents(clean, entity).join('\n')}}`)
         this.contexts.pop()
     }
 
@@ -234,37 +233,32 @@ class Visitor {
         return isDraftEnabled(entity) ? [`static drafts: typeof ${clean}`] : []
     }
 
-    #printEntity(name, entity) {
+    #printEntity(fq, entity) {
         // static .name has to be defined more forcefully: https://github.com/microsoft/TypeScript/issues/442
         const overrideNameProperty = (clazz, content) => `Object.defineProperty(${clazz}, 'name', { value: '${content}' })`
-        const { namespace: ns, name: clean } = this.resolver.untangle(name)
+        const { namespace: ns, entityName: clean, inflection } = this.entityRepository.getByFq(fq)
         const file = this.fileRepository.getNamespaceFile(ns)
-        // entities are expected to be in plural anyway, so we would favour the regular name.
-        // If the user decides to pass a @plural annotation, that gets precedence over the regular name.
-        
-        /*
-        let plural = this.resolver.trimNamespace(util.getPluralAnnotation(entity) ? util.plural4(entity, false) : name)
-        const singular = this.resolver.trimNamespace(util.singular4(entity, true))
-        */
-        let { singular, plural } = this.resolver.inflect({csn: entity, plainName: clean}, ns.asNamespace())
+        let { singular, plural } = inflection
 
         // trimNamespace does not properly detect scoped entities, like A.B where both A and B are
         // entities. So to see if we would run into a naming collision, we forcefully take the last
         // part of the name, so "A.B" and "A.Bs" just become "B" and "Bs" to be compared.
-        // FIXME: put this in a util function
-        if (plural.split('.').at(-1) === `${singular.split('.').at(-1)}_`) {
-            this.logger.warning(
+        if (last(plural) === `${last(singular)}_`) {
+            LOG.warn(
                 `Derived singular and plural forms for '${singular}' are the same. This usually happens when your CDS entities are named following singular flexion. Consider naming your entities in plural or providing '@singular:'/ '@plural:' annotations to have a clear distinction between the two. Plural form will be renamed to '${plural}' to avoid compilation errors within the output.`
             )
         }
+
         // as types are not inflected, their singular will always clash and there is also no plural for them anyway -> skip
-        if (!isType(entity) && `${ns.asNamespace()}.${singular}` in this.csn.xtended.definitions) {
-            this.logger.error(
-                `Derived singular '${singular}' for your entity '${name}', already exists. The resulting types will be erronous. Consider using '@singular:'/ '@plural:' annotations in your model or move the offending declarations into different namespaces to resolve this collision.`
+        // if the user defined their entities in singular form we would also have a false positive here -> skip
+        const namespacedSingular = `${ns.asNamespace()}.${singular}`
+        if (!isType(entity) && namespacedSingular !== fq && namespacedSingular in this.csn.xtended.definitions) {
+            LOG.error(
+                `Derived singular '${singular}' for your entity '${fq}', already exists. The resulting types will be erronous. Consider using '@singular:'/ '@plural:' annotations in your model or move the offending declarations into different namespaces to resolve this collision.`
             )
         }
-        file.addClass(singular, name)
-        file.addClass(plural, name)
+        file.addClass(singular, fq)
+        file.addClass(plural, fq)
 
         const parent = this.resolver.resolveParent(entity.name)
         const buffer = parent && parent.kind === 'entity'
@@ -282,13 +276,13 @@ class Visitor {
 
         // in case of projections `entity` is empty -> retrieve from inferred csn where the actual properties are rolled out
         const target = isProjection(entity) || isView(entity)
-            ? this.csn.inferred.definitions[name]
+            ? this.csn.inferred.definitions[fq]
             : entity
-        
+
         // draft enablement is stored in csn.xtended. Iff we took the entity from csn.inferred, we have to carry the draft-enablement over at this point
         target['@odata.draft.enabled'] = isDraftEnabled(entity)
 
-        this.#aspectify(name, target, buffer, { cleanName: singular })
+        this.#aspectify(fq, target, buffer, { cleanName: singular })
 
         buffer.add(overrideNameProperty(singular, entity.name))
         buffer.add(`Object.defineProperty(${singular}, 'is_singular', { value: true })`)
@@ -299,7 +293,7 @@ class Visitor {
         if (!isType(entity)) {
             if (plural.includes('.')) {
                 // Foo.text -> namespace Foo { class text { ... }}
-                plural = plural.split('.').at(-1)
+                plural = last(plural)
             }
             // plural can not be a type alias to $singular[] but needs to be a proper class instead,
             // so it can get passed as value to CQL functions.
@@ -343,14 +337,14 @@ class Visitor {
     }
 
     /**
-     * @param {string} name
-     * @param {object} operation
-     * @param {'function' | 'action'} kind
+     * @param {string} fq - fully qualified name of the operation
+     * @param {object} operation - CSN
+     * @param {'function' | 'action'} kind - kind of operation
      */
-    #printOperation(name, operation, kind) {
-        this.logger.debug(`Printing operation ${name}:\n${JSON.stringify(operation, null, 2)}`)
-        const ns = this.resolver.resolveNamespace(name.split('.'))
-        const file = this.fileRepository.getNamespaceFile(ns)
+    #printOperation(fq, operation, kind) {
+        LOG.debug(`Printing operation ${fq}:\n${JSON.stringify(operation, null, 2)}`)
+        const { namespace } = this.entityRepository.getByFq(fq)
+        const file = this.fileRepository.getNamespaceFile(namespace)
         const params = this.#stringifyFunctionParams(operation.params, file)
         const returnType = operation.returns
             ? this.resolver.resolveAndRequire(operation.returns, file)
@@ -359,59 +353,59 @@ class Visitor {
             returnType,
             returnType.typeInfo.isArray ? returnType.typeName : returnType.typeInfo.inflection.singular
         )
-        file.addOperation(name.split('.').at(-1), params, returns, kind)
+        file.addOperation(last(fq), params, returns, kind)
     }
 
-    #printType(name, type) {
-        this.logger.debug(`Printing type ${name}:\n${JSON.stringify(type, null, 2)}`)
-        const { namespace: ns, name: clean } = this.resolver.untangle(name)
-        const file = this.fileRepository.getNamespaceFile(ns)
+    #printType(fq, type) {
+        LOG.debug(`Printing type ${fq}:\n${JSON.stringify(type, null, 2)}`)
+        const { namespace, entityName } = this.entityRepository.getByFq(fq)
+        const file = this.fileRepository.getNamespaceFile(namespace)
         // skip references to enums.
         // "Base" enums will always have a builtin type (don't skip those).
         // A type referencing an enum E will be considered an enum itself and have .type === E (skip).
         if ('enum' in type && !isReferenceType(type) && this.resolver.builtinResolver.resolveBuiltin(type.type)) {
-            file.addEnum(name, clean, csnToEnumPairs(type))
+            file.addEnum(fq, entityName, csnToEnumPairs(type))
         } else {
             // alias
-            file.addType(name, clean, this.resolver.resolveAndRequire(type, file).typeName)
+            file.addType(fq, entityName, this.resolver.resolveAndRequire(type, file).typeName)
         }
         // TODO: annotations not handled yet
     }
 
-    #printAspect(name, aspect) {
-        this.logger.debug(`Printing aspect ${name}`)
-        const { namespace: ns, name: clean } = this.resolver.untangle(name)
-        const file = this.fileRepository.getNamespaceFile(ns)
+    #printAspect(fq, aspect) {
+        LOG.debug(`Printing aspect ${fq}`)
+        const { namespace, entityName, inflection } = this.entityRepository.getByFq(fq)
+        const file = this.fileRepository.getNamespaceFile(namespace)
         // aspects are technically classes and can therefore be added to the list of defined classes.
         // Still, when using them as mixins for a class, they need to already be defined.
         // So we separate them into another buffer which is printed before the classes.
-        file.addClass(clean, name)
-        file.aspects.add(`// the following represents the CDS aspect '${clean}'`)
-        this.#aspectify(name, aspect, file.aspects, { cleanName: clean })
+        file.addClass(entityName, fq)
+        file.aspects.add(`// the following represents the CDS aspect '${entityName}'`)
+        this.#aspectify(fq, aspect, file.aspects, { cleanName: inflection.singular })
     }
 
-    #printEvent(name, event) {
-        this.logger.debug(`Printing event ${name}`)
-        const { namespace: ns, name: clean } = this.resolver.untangle(name)
-        const file = this.fileRepository.getNamespaceFile(ns)
-        file.addEvent(clean, name)
+    #printEvent(fq, event) {
+        LOG.debug(`Printing event ${fq}`)
+        const { namespace, entityName } = this.entityRepository.getByFq(fq)
+        const file = this.fileRepository.getNamespaceFile(namespace)
+        file.addEvent(entityName, fq)
         const buffer = file.events.buffer
         buffer.add('// event')
         // only declare classes, as their properties are not optional, so we don't have to do awkward initialisation thereof.
-        buffer.addIndentedBlock(`export declare class ${clean} {`, function() {
+        buffer.addIndentedBlock(`export declare class ${entityName} {`, () => {
             const propOpt = this.options.propertiesOptional
             this.options.propertiesOptional = false
             for (const [ename, element] of Object.entries(event.elements ?? {})) {
                 this.visitElement(ename, element, file, buffer)
             }
             this.options.propertiesOptional = propOpt
-        }.bind(this), '}')
+        }, '}')
     }
 
-    #printService(name, service) {
-        this.logger.debug(`Printing service ${name}:\n${JSON.stringify(service, null, 2)}`)
-        const ns = this.resolver.resolveNamespace(name)
-        const file = this.fileRepository.getNamespaceFile(ns)
+    #printService(fq, service) {
+        LOG.debug(`Printing service ${fq}:\n${JSON.stringify(service, null, 2)}`)
+        const { namespace } = this.entityRepository.getByFq(fq)
+        const file = this.fileRepository.getNamespaceFile(namespace)
         // service.name is clean of namespace
         file.services.buffer.add(`export default { name: '${service.name}' }`)
         file.addService(service.name)
@@ -420,36 +414,36 @@ class Visitor {
     /**
      * Visits a single entity from the CSN's definition field.
      * Will call #printEntity or #printAction based on the entity's kind.
-     * @param {string} name - name of the entity, fully qualified as is used in the definition field.
+     * @param {string} fq - name of the entity, fully qualified as is used in the definition field.
      * @param {CSN} entity - CSN data belonging to the entity to perform lookups in.
      */
-    visitEntity(name, entity) {
+    visitEntity(fq, entity) {
         switch (entity.kind) {
         case 'entity':
-            this.#printEntity(name, entity)
+            this.#printEntity(fq, entity)
             break
         case 'action':
         case 'function':
-            this.#printOperation(name, entity, entity.kind)
+            this.#printOperation(fq, entity, entity.kind)
             break
         case 'aspect':
-            this.#printAspect(name, entity)
+            this.#printAspect(fq, entity)
             break
         case 'type': {
             // types like inline definitions can be used very similarly to entities.
             // They can be extended, contain inline enums, etc., so we treat them as entities.
             const handler = entity.elements ? this.#printEntity : this.#printType
-            handler.call(this, name, entity)
+            handler.call(this, fq, entity)
             break
         }
         case 'event':
-            this.#printEvent(name, entity)
+            this.#printEvent(fq, entity)
             break
         case 'service':
-            this.#printService(name, entity)
+            this.#printService(fq, entity)
             break
         default:
-            this.logger.debug(`Unhandled entity kind '${entity.kind}'.`)
+            LOG.debug(`Unhandled entity kind '${entity.kind}'.`)
         }
     }
 
@@ -459,7 +453,7 @@ class Visitor {
      * refer to types via their alias that hides the aspectification.
      * If we attempt to directly refer to this alias while it has not been fully created,
      * that will result in a TS error.
-     * @param {string} entityName
+     * @param {string} fq - fully qualified name of the entity
      * @returns {boolean} true, if `entityName` refers to the surrounding class
      * @example
      * ```ts
@@ -469,14 +463,14 @@ class Visitor {
      * }
      * ```
      */
-    isSelfReference(entityName) {
-        return entityName === this.contexts.at(-1)?.entity
+    isSelfReference(fq) {
+        return fq === this.contexts.at(-1)?.entity
     }
 
     /**
      * Visits a single element in an entity.
      * @param {string} name - name of the element
-     * @param {import('./components/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.
      * @returns @see InlineDeclarationResolver.visitElement

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Generates .ts files for a CDS model to receive code completion in VS Code",
   "main": "index.js",
   "repository": "github:cap-js/cds-typer",
@@ -19,6 +19,7 @@
     "test:all": "jest",
     "test": "npm run test:smoke && npm run test:unit",
     "lint": "npx eslint .",
+    "lint:fix": "npx eslint . --fix",
     "cli": "node lib/cli.js",
     "doc:clean": "rm -rf ./doc",
     "doc:prepare": "npm run doc:clean && mkdir -p doc/types",