@cap-js/cds-typer 0.11.1 → 0.13.0

package/CHANGELOG.md

@@ -4,12 +4,25 @@ 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.12.0 - TBD
+## Version 0.14.0 - TBD
+
+## Version 0.13.0 - 2023-12-06
+### Changes
+- Enums are now generated ecplicitly in the respective _index.js_ files and don't have to extract their values from the model at runtime anymore
+
+### Added
+- The `excluding` clause in projections now actually excludes the specified properties in the generated types
+
+## Version 0.12.0 - 2023-11-23
 
 ### Changed
+- Generate `cds.LargeBinary` as string, buffer, _or readable_ in the case of media content
 
 ### Added
+- Added support for the `not null` modifier
+
 ### Fixed
+- Now using names of enum values in generated _index.js_ files if no explicit value is present
 
 ## Version 0.11.1 - 2023-10-12
 
@@ -17,7 +30,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
 ### Added
 ### Fixed
-Fixed how service names are exported as default export
+- Fixed how service names are exported as default export
 
 ## Version 0.11.0 - 2023-10-10
 

package/lib/cli.js

@@ -99,8 +99,4 @@ const main = async (args) => {
 
 if (require.main === module) {
     main(parseCommandlineArgs(process.argv.slice(2), flags))
-}
-
-function helpToCapire() {
-
 }

package/lib/components/enum.js

@@ -31,8 +31,8 @@ function printEnum(buffer, name, kvs, options = {}) {
     buffer.indent()
     const vals = new Set()
     for (const [k, v] of kvs) {
-        buffer.add(`${k}: ${JSON.stringify(v)},`)
-        vals.add(JSON.stringify(v.val ?? v))  // in case of wrapped vals we need to unwrap here for the type
+        buffer.add(`${k}: ${v},`)
+        vals.add(v?.val ?? v)  // in case of wrapped vals we need to unwrap here for the type
     }
     buffer.outdent()
     buffer.add('} as const;')
@@ -41,27 +41,32 @@ function printEnum(buffer, name, kvs, options = {}) {
 }
 
 // in case of strings, wrap in quotes and fallback to key to make sure values are attached for every key
-const enumVal = (key, value, enumType) => enumType === 'cds.String' ? `${value ?? key}` : value
+const enumVal = (key, value, enumType) => enumType === 'cds.String' ? JSON.stringify(`${value ?? key}`) : value
 
 /**
+ * Converts a CSN type describing an enum into a list of kv-pairs.
+ * Values from CSN are unwrapped from their `.val` structure and
+ * will fall back to the key if no value is provided.
+ * 
  * @param {{enum: {[key: name]: string}, type: string}} enumCsn
  * @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 (anoymous enum types).
+ *  to mimic the runtime as closely as possible (inline enum types).
  *  Stripping that additional wrapper would be more readable for users.
+ * 
  * @example
  * ```ts 
- * const csn = {enum: {x: {val: 42}, y: {val: -42}}}
- * csnToEnum(csn) // -> [['x', 42], ['y': -42]]
- * csnToEnum(csn, {unwrapVals: false}) // -> [['x', {val:42}], ['y': {val:-42}]]
+ * 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']]
  * ```
  */
-const csnToEnum = ({enum: enm, type}, options = {}) => {
+const csnToEnumPairs = ({enum: enm, type}, options = {}) => {
     options = {...{unwrapVals: true}, ...options}
     return Object.entries(enm).map(([k, v]) => {
         const val = enumVal(k, v.val, type)
-        return [k, options.unwrapVals ? val : { val }]
+        return [k, (options.unwrapVals ? val : { val })]
     })
 }
 
@@ -69,7 +74,7 @@ const csnToEnum = ({enum: enm, type}, options = {}) => {
  * @param {string} entity
  * @param {string} property
  */
-const propertyToAnonymousEnumName = (entity, property) => `${entity}_${property}`
+const propertyToInlineEnumName = (entity, property) => `${entity}_${property}`
 
 /**
  * A type is considered to be an inline enum, iff it has a `.enum` property
@@ -82,27 +87,30 @@ const propertyToAnonymousEnumName = (entity, property) => `${entity}_${property}
  */
 const isInlineEnumType = (element, csn) => element.enum && !(element.type in csn.definitions)
 
-const stringifyEnumImplementation = (name, enm) => `module.exports.${name} = Object.fromEntries(Object.entries(${enm}).map(([k,v]) => [k,v.val]))`
-
-/**
- * @param {string} name
- * @param {string} fq
- * @returns {string}
- */
-const stringifyNamedEnum = (name, fq) => stringifyEnumImplementation(name, `cds.model.definitions['${fq}'].enum`)
 /**
+ * Stringifies an enum into a runtime artifact.
+ * ```cds
+ * type Language: String enum {
+ *   DE = "German";
+ *   EN = "English";
+ *   FR;
+ * }
+ * ```
+ * becomes
+ * 
+ * ```js
+ * module.exports.Language = { DE: "German", EN: "English", FR: "FR" }
+ * ```
  * @param {string} name
- * @param {string} fq
- * @param {string} property
- * @returns {string}
+ * @param {[string, string][]} kvs a list of key-value pairs. Values that are falsey are replaced by 
  */
-const stringifyAnonymousEnum = (name, fq, property) => stringifyEnumImplementation(fq, `cds.model.definitions['${name}'].elements.${property}.enum`)
+const stringifyEnumImplementation = (name, kvs) => `module.exports.${name} = { ${kvs.map(([k,v]) => `${k}: ${v}`).join(', ')} }`
+
 
 module.exports = {
     printEnum,
-    csnToEnum,
-    propertyToAnonymousEnumName,
+    csnToEnumPairs,
+    propertyToInlineEnumName,
     isInlineEnumType,
-    stringifyNamedEnum,
-    stringifyAnonymousEnum
+    stringifyEnumImplementation
 }

package/lib/components/inline.js

@@ -17,6 +17,7 @@ class InlineDeclarationResolver {
      * @protected
      * @abstract
      */
+    // eslint-disable-next-line no-unused-vars
     printInlineType(name, type, buffer, statementEnd) { /* abstract */ }
 
     /**
@@ -84,6 +85,17 @@ class InlineDeclarationResolver {
         return this.visitor.options.propertiesOptional ? '?:' : ':'
     }
 
+    /**
+     * It returns TypeScript datatype for provided TS property
+     * @param {{typeName: string, typeInfo: TypeResolveInfo & { inflection: Inflection } }} type
+     * @param {string} typeName name of the TypeScript property
+     * @return {string} the datatype to be presented on TypeScript layer
+     * @public
+     */
+    getPropertyDatatype(type, typeName = type.typeName) {
+        return type.typeInfo.isNotNull ? typeName : `${typeName} | null`
+    }
+
     /** @param {import('../visitor').Visitor} visitor */
     constructor(visitor) {
         this.visitor = visitor
@@ -111,6 +123,7 @@ class InlineDeclarationResolver {
      * @public
      * @abstract
      */
+    // eslint-disable-next-line no-unused-vars
     getTypeLookup(members) { /* abstract */ return '' }
 }
 
@@ -142,7 +155,7 @@ class FlatInlineDeclarationResolver extends InlineDeclarationResolver {
     flatten(prefix, type) {
         return type.typeInfo.structuredType
             ? Object.entries(type.typeInfo.structuredType).map(([k,v]) => this.flatten(`${this.prefix(prefix)}${k}`, v))
-            : [`${prefix}${this.getPropertyTypeSeparator()} ${type.typeName}`]
+            : [`${prefix}${this.getPropertyTypeSeparator()} ${this.getPropertyDatatype(type)}`]
     }
 
     printInlineType(name, type, buffer) {
@@ -192,9 +205,9 @@ class StructuredInlineDeclarationResolver extends InlineDeclarationResolver {
                 this.flatten(n, t, buffer)
             }
             buffer.outdent()
-            buffer.add(`}${lineEnding}`)
+            buffer.add(`}${this.getPropertyDatatype(type, '')}${lineEnding}`)
         } else {
-            buffer.add(`${name}${this.getPropertyTypeSeparator()} ${type.typeName}${lineEnding}`)
+            buffer.add(`${name}${this.getPropertyTypeSeparator()} ${this.getPropertyDatatype(type)}${lineEnding}`)
         }
         this.printDepth--
         return buffer

package/lib/components/resolver.js

@@ -1,10 +1,11 @@
 'use strict'
 
 const util = require('../util')
-const { Buffer, SourceFile, Path, Library, baseDefinitions } = require("../file")
+// eslint-disable-next-line no-unused-vars
+const { Buffer, SourceFile, Path, Library, baseDefinitions } = require('../file')
 const { deepRequire, createToManyAssociation, createToOneAssociation, createArrayOf, createCompositionOfMany, createCompositionOfOne } = require('./wrappers')
-const { StructuredInlineDeclarationResolver } = require("./inline")
-const { isInlineEnumType, propertyToInlineEnumName, propertyToAnonymousEnumName } = require('./enum')
+const { StructuredInlineDeclarationResolver } = require('./inline')
+const { isInlineEnumType, propertyToInlineEnumName } = require('./enum')
 
 /** @typedef {{ cardinality?: { max?: '*' | number } }} EntityCSN */
 /** @typedef {{ definitions?: Object<string, EntityCSN> }} CSN */
@@ -22,6 +23,7 @@ const { isInlineEnumType, propertyToInlineEnumName, propertyToAnonymousEnumName
  * ```
  * @typedef {{
  *    isBuiltin: boolean,
+ *    isNotNull: boolean,
  *    isInlineDeclaration: boolean,
  *    isForeignKeyReference: boolean,
  *    isArray: boolean,
@@ -41,7 +43,7 @@ const Builtins = {
     String: 'string',
     Binary: 'string',
     LargeString: 'string',
-    LargeBinary: 'Buffer | string',
+    LargeBinary: 'Buffer | string | {value: import("stream").Readable, $mediaContentType: string, $mediaContentDispositionFilename?: string, $mediaContentDispositionType?: string}',
     Integer: 'number',
     UInt8: 'number',
     Int16: 'number',
@@ -231,6 +233,8 @@ class Resolver {
 
             if (toOne && toMany) {
                 const target = element.items ?? (typeof element.target === 'string' ? { type: element.target } : element.target)
+                /** set `notNull = true` to avoid repeated `| not null` TS construction */
+                target.notNull = true
                 const { singular, plural } = this.resolveAndRequire(target, file).typeInfo.inflection
                 typeName =
                     cardinality > 1 ? toMany(plural) : toOne(this.visitor.isSelfReference(target) ? 'this' : singular)
@@ -254,7 +258,7 @@ class Resolver {
                 }
 
                 if (element.type.ref?.length > 1) {
-                    const [entity, ...members] = element.type.ref
+                    const [, ...members] = element.type.ref
                     const lookup = this.visitor.inlineDeclarationResolver.getTypeLookup(members)
                     typeName = deepRequire(typeInfo.inflection.singular, lookup)
                     file.addImport(baseDefinitions.path)
@@ -348,11 +352,16 @@ class Resolver {
             return element
         }
 
+        const cardinality = this.getMaxCardinality(element)
+
         const result = {
             isBuiltin: false, // will be rectified in the corresponding handlers, if needed
             isInlineDeclaration: false,
             isForeignKeyReference: false,
             isArray: false,
+            isNotNull: element?.isRefNotNull !== undefined 
+                ? element?.isRefNotNull 
+                : element?.key || element?.notNull || cardinality > 1,
         }
 
         if (element?.type === undefined) {
@@ -365,7 +374,7 @@ class Resolver {
                 // 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 = propertyToAnonymousEnumName(cleanEntityName, element.name)
+                const enumName = propertyToInlineEnumName(cleanEntityName, element.name)
                 result.type = enumName
                 result.plainName = enumName
                 result.isInlineDeclaration = true
@@ -377,6 +386,8 @@ class Resolver {
         // objects and arrays
         if (element?.items) {
             result.isArray = true
+            // 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)
             //delete element.items

package/lib/csn.js

@@ -221,49 +221,6 @@ function propagateForeignKeys(csn) {
     }
 }
 
-/** 
-* Entities inherit their ancestors annotations:
-* https://cap.cloud.sap/docs/cds/cdl#annotation-propagation
-* This is a problem if we annotate @singular/ @plural to an entity A,
-* as we don't want all descendents B, C, ... to share the ancestor's
-* annotated inflexion
-* -> remove all such annotations that appear in a parent as well.
-* BUT: we can't just delete the attributes. Imagine three classes
-* A <- B <- C
-* where A contains a @singular annotation.
-* If we erase the annotation from B, C will still contain it and
-* can not detect that its own annotation was inherited without
-* travelling up the entire inheritance chain up to A.
-* So instead, we monkey patch and maintain a dictionary "erased"
-* when removing an annotation which we also check.
-* @deprecated since we use the xtended flavour for CSN, we don't need to fix this anymore
-*/
-function propagateInflectionAnnotations(csn) {
-    const erase = (entity, parent, attr) => {
-        if (attr in entity) {
-            const ea = entity[attr]
-            if (parent[attr] === ea || (parent.erased && parent.erased[attr] === ea)) {
-                entity.erased ??= {}
-                entity.erased[attr] = ea
-                delete entity[attr]
-                //this.logger.info(`Removing inherited attribute ${attr} from ${entity.name}.`)
-            }
-        }
-    }
-
-    for (const entity of Object.values(csn.definitions)) {
-        let i = 0
-        while (
-            (getSingularAnnotation(entity) || getPluralAnnotation(entity)) &&
-            i < (entity.includes ?? []).length
-        ) {
-            const parent = csn.definitions[entity.includes[i]]
-            Object.values(annotations).flat().forEach(an => erase(entity, parent, an))
-            i++
-        }
-    }
-}
-
 function amendCSN(csn) {
     unrollDraftability(csn)
     propagateForeignKeys(csn)

package/lib/file.js

@@ -2,7 +2,7 @@
 
 const fs = require('fs').promises
 const { readFileSync } = require('fs')
-const { printEnum, stringifyNamedEnum, stringifyAnonymousEnum, propertyToAnonymousEnumName } = require('./components/enum')
+const { printEnum, propertyToInlineEnumName, stringifyEnumImplementation } = require('./components/enum')
 const path = require('path')
 
 const AUTO_GEN_NOTE = "// This is an automatically generated file. Please do not change its contents manually!"
@@ -104,8 +104,8 @@ class SourceFile extends File {
         this.events = { buffer: new Buffer(), fqs: []} 
         /** @type {Buffer} */
         this.types = new Buffer()
-        /** @type {{ buffer: Buffer, fqs: {name: string, fq: string, property?: string}[]}} */
-        this.enums = { buffer: new Buffer(), fqs: [] }
+        /** @type {{ buffer: Buffer, data: {kvs: [string[]], name: string, fq: string, property?: string}[]}} */
+        this.enums = { buffer: new Buffer(), data: [] }
         /** @type {{ buffer: Buffer }} */
         this.inlineEnums = { buffer: new Buffer() }
         /** @type {Buffer} */
@@ -226,28 +226,28 @@ class SourceFile extends File {
      * @param {string} fq fully qualified name of the enum (entity name within CSN)
      * @param {string} name local name of the enum
      * @param {[string, string][]} kvs list of key-value pairs
-     * @param {string} [property] property to which the enum is attached. 
-     *  If given, the enum is considered to be an anonymous inline definition of an enum.
+     * @param {string} [property] property to which the enum is attached.
+     *  If given, the enum is considered to be an inline definition of an enum.
      *  If not, it is considered to be regular, named enum.
      */
     addEnum(fq, name, kvs) {
-        this.enums.fqs.push({ name, fq })
+        this.enums.data.push({ name, fq, kvs })
         printEnum(this.enums.buffer, name, kvs)
     }
 
     /**
-     * Adds an anonymous enum to this file.
+     * Adds an inline enum to this file.
      * @param {string} entityCleanName name of the entity the enum is attached to without namespace
      * @param {string} entityFqName name of the entity the enum is attached to with namespace
      * 
      * @param {string} propertyName property to which the enum is attached. 
      * @param {[string, string][]} kvs list of key-value pairs
-     *  If given, the enum is considered to be an anonymous inline definition of an enum.
+     *  If given, the enum is considered to be an inline definition of an enum.
      *  If not, it is considered to be regular, named enum.
      * 
      * @example
      * ```js
-     * addAnonymousEnum('Books.genre', 'Books', 'genre', [['horror','horror']])
+     * addInlineEnum('Books.genre', 'Books', 'genre', [['horror','horror']])
      * ```
      * generates
      * ```js
@@ -266,13 +266,14 @@ class SourceFile extends File {
      * }
      * ```
      */
-    addAnonymousEnum(entityCleanName, entityFqName, propertyName, kvs) {
-        this.enums.fqs.push({ 
+    addInlineEnum(entityCleanName, entityFqName, propertyName, kvs) {
+        this.enums.data.push({ 
             name: entityFqName,
             property: propertyName,
+            kvs,
             fq: `${entityCleanName}.${propertyName}`
         })
-        printEnum(this.inlineEnums.buffer, propertyToAnonymousEnumName(entityCleanName, propertyName), kvs, {export: false})
+        printEnum(this.inlineEnums.buffer, propertyToInlineEnumName(entityCleanName, propertyName), kvs, {export: false})
     }
 
     /**
@@ -410,9 +411,7 @@ class SourceFile extends File {
             .concat(['// actions'])
             .concat(this.actions.names.map(name => `module.exports.${name} = '${name}'`))
             .concat(['// enums'])
-            .concat(this.enums.fqs.map(({name, fq, property}) => property 
-                ? stringifyAnonymousEnum(name, fq, property)
-                : stringifyNamedEnum(name, fq)))
+            .concat(this.enums.data.map(({name, kvs}) => stringifyEnumImplementation(name, kvs)))
             .join('\n') + '\n'
     }
 }
@@ -608,6 +607,7 @@ const writeout = async (root, sources) =>
             } catch (err) {
                 // eslint-disable-next-line no-console
                 console.error(`Could not create parent directory ${dir}: ${err}.`)
+                console.error(err.stack)
             }
             return dir
         })

package/lib/visitor.js

@@ -3,12 +3,13 @@
 const util = require('./util')
 
 const { amendCSN } = require('./csn')
+// eslint-disable-next-line no-unused-vars
 const { SourceFile, baseDefinitions, Buffer } = require('./file')
 const { FlatInlineDeclarationResolver, StructuredInlineDeclarationResolver } = require('./components/inline')
 const { Resolver } = require('./components/resolver')
 const { Logger } = require('./logging')
 const { docify } = require('./components/wrappers')
-const { csnToEnum, propertyToAnonymousEnumName, isInlineEnumType } = require('./components/enum')
+const { csnToEnumPairs, propertyToInlineEnumName, isInlineEnumType } = require('./components/enum')
 
  /** @typedef {import('./file').File} File */
  /** @typedef {{ entity: String }} Context */
@@ -116,7 +117,11 @@ 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) {
-                this.visitEntity(name, this.csn.xtended.definitions[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}`)
             }
@@ -151,7 +156,9 @@ class Visitor {
         buffer.indent()
 
         const enums = []
-        for (const [ename, element] of Object.entries(entity.elements ?? {})) {
+        const exclusions = new Set(entity.projection?.excluding ?? [])
+        const elements = Object.entries(entity.elements ?? {}).filter(([ename]) => !exclusions.has(ename))
+        for (const [ename, element] of elements) {
             this.visitElement(ename, element, file, buffer)
 
             // make foreign keys explicit
@@ -160,7 +167,10 @@ 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, kelement] of Object.entries(this.csn.xtended.definitions[element.target]?.keys ?? {})) {
-                    this.visitElement(`${ename}_${kname}`, kelement, file, buffer)
+                    if (this.resolver.getMaxCardinality(element) === 1) {
+                        kelement.isRefNotNull = !!element.notNull || !!element.key
+                        this.visitElement(`${ename}_${kname}`, kelement, file, buffer)
+                    }
                 }
             }
 
@@ -172,8 +182,8 @@ class Visitor {
 
         buffer.indent()
         for (const e of enums) {
-            buffer.add(`static ${e.name} = ${propertyToAnonymousEnumName(clean, e.name)}`)
-            file.addAnonymousEnum(clean, name, e.name, csnToEnum(e, {unwrapVals: true}))
+            buffer.add(`static ${e.name} = ${propertyToInlineEnumName(clean, e.name)}`)
+            file.addInlineEnum(clean, name, e.name, csnToEnumPairs(e, {unwrapVals: true}))
         }
         buffer.add('static actions: {')
         buffer.indent()
@@ -299,7 +309,7 @@ class Visitor {
                 .filter(([, type]) => type?.type !== '$self' && !(type.items?.type === '$self'))
                 .map(([name, type]) => [
                     name,
-                    this.resolver.resolveAndRequire(type, file).typeName,
+                    this.resolver.visitor.inlineDeclarationResolver.getPropertyDatatype(this.resolver.resolveAndRequire(type, file)),
                 ])
             : []
     }
@@ -310,7 +320,9 @@ class Visitor {
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
         const params = this.#stringifyFunctionParams(func.params, file)
-        const returns = this.resolver.resolveAndRequire(func.returns, file).typeName
+        const returns = this.resolver.visitor.inlineDeclarationResolver.getPropertyDatatype(
+            this.resolver.resolveAndRequire(func.returns, file)
+        )
         file.addFunction(name.split('.').at(-1), params, returns)
     }
 
@@ -319,7 +331,9 @@ class Visitor {
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
         const params = this.#stringifyFunctionParams(action.params, file)
-        const returns = this.resolver.resolveAndRequire(action.returns, file).typeName
+        const returns = this.resolver.visitor.inlineDeclarationResolver.getPropertyDatatype(
+            this.resolver.resolveAndRequire(action.returns, file)
+        )
         file.addAction(name.split('.').at(-1), params, returns)
     }
 
@@ -329,7 +343,7 @@ class Visitor {
         const ns = this.resolver.resolveNamespace(name.split('.'))
         const file = this.getNamespaceFile(ns)
         if ('enum' in type) {
-            file.addEnum(name, clean, csnToEnum(type))
+            file.addEnum(name, clean, csnToEnumPairs(type))
         } else {
             // alias
             file.addType(name, clean, this.resolver.resolveAndRequire(type, file).typeName)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/cds-typer",
-  "version": "0.11.1",
+  "version": "0.13.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",
@@ -17,7 +17,7 @@
     "test:integration": "jest --projects test/int.jest.config.js",
     "test:all": "jest",
     "test": "npm run test:unit",
-    "lint": "eslint",
+    "lint": "npx eslint .",
     "cli": "node lib/cli.js",
     "doc:clean": "rm -rf ./doc",
     "doc:prepare": "npm run doc:clean && mkdir -p doc/types",
@@ -40,10 +40,9 @@
     "@sap/cds": ">=6"
   },
   "devDependencies": {
+    "@babel/eslint-parser": "^7.23.3",
     "acorn": "^8.10.0",
     "eslint": "^8.15.0",
-    "eslint-config-prettier": "^8.5.0",
-    "eslint-plugin-prettier": "^4.0.0",
     "jest": "^29",
     "typescript": ">=4.6.4"
   },