@cap-js/db-service 1.0.0 → 1.1.0

package/lib/infer/index.js

@@ -4,7 +4,6 @@ const cds = require('@sap/cds/lib')
 
 const JoinTree = require('./join-tree')
 const { pseudos } = require('./pseudos')
-// REVISIT: we should always return cds.linked elements
 const cdsTypes = cds.linked({
   definitions: {
     Timestamp: { type: 'cds.Timestamp' },
@@ -18,11 +17,10 @@ const cdsTypes = cds.linked({
   },
 }).definitions
 for (const each in cdsTypes) cdsTypes[`cds.${each}`] = cdsTypes[each]
-
 /**
- * @param {CQN|CQL} originalQuery
- * @param {CSN} [model]
- * @returns {InferredCQN} = q with .target and .elements
+ * @param {import('@sap/cds/apis/cqn').Query|string} originalQuery
+ * @param {import('@sap/cds/apis/csn').CSN} [model]
+ * @returns {import('./cqn').Query} = q with .target and .elements
  */
 function infer(originalQuery, model = cds.context?.model || cds.model) {
   if (!model) cds.error('Please specify a model')
@@ -40,6 +38,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
     inferred.CREATE ||
     inferred.DROP ||
     inferred.STREAM
+
+  // cache for already processed calculated elements
+  const alreadySeenCalcElements = new Set()
+
   const sources = inferTarget(_.from || _.into || _.entity, {})
   const joinTree = new JoinTree(sources)
   const aliases = Object.keys(sources)
@@ -134,11 +136,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * next 'ref' step should be looked up.
    *
    *
-   * @param {Object} arg - The argument object that will be augmented with additional properties.
+   * @param {object} arg - The argument object that will be augmented with additional properties.
    *                        It must contain a 'ref' property, which is an array representing the steps to be processed.
    *                        Optionally, it can also contain an 'xpr' property, which is also processed recursively.
    *
-   * @param {Object} $baseLink - Optional parameter. It represents the environment in which the first 'ref' step should be
+   * @param {object} $baseLink - Optional parameter. It represents the environment in which the first 'ref' step should be
    *                             resolved. It's needed for infix filter / expand columns. It must contain a 'definition'
    *                             property, which is an object representing the base environment.
    *
@@ -177,7 +179,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             if (!expandOrExists && nextStep && !(nextStep in e.foreignKeys))
               throw new Error(`Only foreign keys of "${e.name}" can be accessed in infix filter`)
           }
-          arg.$refLinks.push({ definition: e, target: e._target || e })
+          arg.$refLinks.push({ definition: e, target: definition })
           // filter paths are flattened
           // REVISIT: too much augmentation -> better remove flatName..
           Object.defineProperty(arg, 'flatName', { value: ref.join('_'), writable: true })
@@ -188,7 +190,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         }
       } else {
         const recent = arg.$refLinks[i - 1]
-        const { elements } = recent.target
+        const { elements } = recent.definition._target || recent.definition
         const e = elements[id]
         if (!e) throw new Error(`"${id}" not found in the elements of "${arg.$refLinks[i - 1].definition.name}"`)
         arg.$refLinks.push({ definition: e, target: e._target || e })
@@ -216,6 +218,11 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         } else throw new Error('A filter can only be provided when navigating along associations')
       }
     })
+    const { definition, target } = arg.$refLinks[arg.$refLinks.length - 1]
+    if (definition.value) {
+      // nested calculated element
+      attachRefLinksToArg(definition.value, { definition: definition.parent, target }, true)
+    }
   }
 
   /**
@@ -227,7 +234,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * Each entry in the `$combinedElements` dictionary maps from the element name
    * to an array of objects containing the index and table alias where the element can be found.
    *
-   * @returns {Object} The `$combinedElements` dictionary, which maps element names to an array of objects
+   * @returns {object} The `$combinedElements` dictionary, which maps element names to an array of objects
    *                   containing the index and table alias where the element can be found.
    */
   function inferCombinedElements() {
@@ -264,9 +271,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
    * Also walks over other `ref`s in the query, validates them, and attaches `$refLinks`.
    * This includes handling `where`, infix filters within column `refs`, or other `csn` paths.
    *
-   * @param {Object} $combinedElements The `$combinedElements` dictionary of the query, which maps element names
+   * @param {object} $combinedElements The `$combinedElements` dictionary of the query, which maps element names
    *                                   to an array of objects containing the index and table alias where the element can be found.
-   * @returns {Object} The inferred `elements` dictionary of the query, which maps element names to their corresponding definitions.
+   * @returns {object} The inferred `elements` dictionary of the query, which maps element names to their corresponding definitions.
    */
   function inferQueryElements($combinedElements) {
     let queryElements = {}
@@ -275,7 +282,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       inferElementsFromWildCard(aliases)
     } else {
       let wildcardSelect = false
-      const refs = []
+      const dollarSelfRefs = []
       columns.forEach(col => {
         if (col === '*') {
           wildcardSelect = true
@@ -294,24 +301,24 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           }
           setElementOnColumns(col, queryElements[as])
         } else if (col.ref) {
-          refs.push(col)
+          const firstStepIsTableAlias =
+            (col.ref.length > 1 && col.ref[0] in sources) ||
+            // nested projection on table alias
+            (col.ref.length === 1 && col.ref[0] in sources && col.inline)
+          const firstStepIsSelf =
+            !firstStepIsTableAlias && col.ref.length > 1 && ['$self', '$projection'].includes(col.ref[0])
+          // we must handle $self references after the query elements have been calculated
+          if (firstStepIsSelf) dollarSelfRefs.push(col)
+          else handleRef(col)
         } else if (col.expand) {
           inferQueryElement(col)
         } else {
           throw cds.error`Not supported: ${JSON.stringify(col)}`
         }
       })
-      refs.forEach(col => {
-        inferQueryElement(col)
-        const { definition } = col.$refLinks[col.$refLinks.length - 1]
-        if (col.cast)
-          // final type overwritten -> element not visible anymore
-          setElementOnColumns(col, getElementForCast(col))
-        else if ((col.ref.length === 1) & (col.ref[0] === '$user'))
-          // shortcut to $user.id
-          setElementOnColumns(col, queryElements[col.as || '$user'])
-        else setElementOnColumns(col, definition)
-      })
+
+      if (dollarSelfRefs.length) inferDollarSelfRefs(dollarSelfRefs)
+
       if (wildcardSelect) inferElementsFromWildCard(aliases)
     }
     if (orderBy) {
@@ -359,6 +366,54 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
     return queryElements
 
+    /**
+     * Processes references starting with `$self`, which are intended to target other query elements.
+     * These `$self` paths must be handled after processing the "regular" columns since they are dependent on other query elements.
+     *
+     * This function checks for `$self` references that may target other `$self` columns, and delays their processing.
+     * `$self` references not targeting other `$self` references are handled by the generic `handleRef` function immediately.
+     *
+     * @param {array} dollarSelfColumns - An array of column objects containing `$self` references.
+     */
+    function inferDollarSelfRefs(dollarSelfColumns) {
+      do {
+        const unprocessedColumns = []
+
+        for (const currentDollarSelfColumn of dollarSelfColumns) {
+          const { ref } = currentDollarSelfColumn
+          const stepToFind = ref[1]
+
+          const referencesOtherDollarSelfColumn = dollarSelfColumns.find(
+            otherDollarSelfCol =>
+              otherDollarSelfCol !== currentDollarSelfColumn &&
+              (otherDollarSelfCol.as
+                ? stepToFind === otherDollarSelfCol.as
+                : stepToFind === otherDollarSelfCol.ref?.[otherDollarSelfCol.ref.length - 1]),
+          )
+
+          if (referencesOtherDollarSelfColumn) {
+            unprocessedColumns.push(currentDollarSelfColumn)
+          } else {
+            handleRef(currentDollarSelfColumn)
+          }
+        }
+
+        dollarSelfColumns = unprocessedColumns
+      } while (dollarSelfColumns.length > 0)
+    }
+
+    function handleRef(col) {
+      inferQueryElement(col)
+      const { definition } = col.$refLinks[col.$refLinks.length - 1]
+      if (col.cast)
+        // final type overwritten -> element not visible anymore
+        setElementOnColumns(col, getElementForCast(col))
+      else if ((col.ref.length === 1) & (col.ref[0] === '$user'))
+        // shortcut to $user.id
+        setElementOnColumns(col, queryElements[col.as || '$user'])
+      else setElementOnColumns(col, definition)
+    }
+
     /**
      * This function is responsible for inferring a query element based on a provided column.
      * It initializes and attaches a non-enumerable `$refLinks` property to the column,
@@ -396,7 +451,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
      */
 
     function inferQueryElement(column, insertIntoQueryElements = true, $baseLink = null, context) {
-      const { inExists, inExpr, inNestedProjection } = context || {}
+      const { inExists, inExpr, inNestedProjection, inCalcElement } = context || {}
       if (column.param) return // parameter references are only resolved into values on execution e.g. :val, :1 or ?
       if (column.args) column.args.forEach(arg => inferQueryElement(arg, false, $baseLink, context)) // e.g. function in expression
       if (column.list) column.list.forEach(arg => inferQueryElement(arg, false, $baseLink, context))
@@ -438,7 +493,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const elements = definition.elements || definition._target?.elements
             if (elements && id in elements) {
               const element = elements[id]
-              if (!inExists && !inNestedProjection && element.target) {
+              if (!inExists && !inNestedProjection && !inCalcElement && element.target) {
                 // only fk access in infix filter
                 const nextStep = column.ref[1]?.id || column.ref[1]
                 // no unmanaged assoc in infix filter path
@@ -452,7 +507,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
                 if (nextStep && !(nextStep in element.foreignKeys))
                   throw new Error(`Only foreign keys of "${element.name}" can be accessed in infix filter`)
               }
-              column.$refLinks.push({ definition: elements[id], target })
+              const resolvableIn = definition.target ? definition._target : target
+              column.$refLinks.push({ definition: elements[id], target: resolvableIn })
             } else {
               stepNotFoundInPredecessor(id, definition.name)
             }
@@ -477,14 +533,25 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         } else {
           const { definition } = column.$refLinks[i - 1]
           const elements = definition.elements || definition._target?.elements
-          if (elements && id in elements) {
-            const $refLink = { definition: elements[id], target: column.$refLinks[i - 1].target }
+          const element = elements?.[id]
+
+          if (firstStepIsSelf && element?.isAssociation) {
+            throw cds.error(
+              `Paths starting with “$self” must not contain steps of type “cds.Association”: ref: [ ${column.ref.map(
+                idOnly,
+              )} ]`,
+            )
+          }
+
+          const target = definition._target || column.$refLinks[i - 1].target
+          if (element) {
+            const $refLink = { definition: elements[id], target }
             column.$refLinks.push($refLink)
           } else if (firstStepIsSelf) {
             stepNotFoundInColumnList(id)
           } else if (column.ref[0] === '$user' && pseudoPath) {
             // `$user.some.unknown.element` -> no error
-            column.$refLinks.push({ definition: {}, target: column.$refLinks[i - 1].target })
+            column.$refLinks.push({ definition: {}, target })
           } else if (id === '$dummy') {
             // `some.known.element.$dummy` -> no error; used by cds.ql to simulate joins
             column.$refLinks.push({ definition: { name: '$dummy', parent: column.$refLinks[i - 1].target } })
@@ -504,7 +571,9 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             : null
           if (foreignKeyAlias) nameSegments.push(foreignKeyAlias)
           else if (skipAliasedFkSegmentsOfNameStack[0] === id) skipAliasedFkSegmentsOfNameStack.shift()
-          else nameSegments.push(id)
+          else {
+            nameSegments.push(firstStepIsSelf && i === 1 ? element.__proto__.name : id)
+          }
         }
 
         if (step.where) {
@@ -567,7 +636,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
               }
               if (queryElements[elementName] !== undefined)
                 throw new Error(`Duplicate definition of element “${elementName}”`)
-              queryElements[elementName] = getCopyWithAnnos(column, leafArt)
+              const element = getCopyWithAnnos(column, leafArt)
+              queryElements[elementName] = element
             }
           }
         }
@@ -584,19 +654,27 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           return
         }
       }
-      const virtual = (column.$refLinks[column.$refLinks.length - 1].definition.virtual || !isPersisted) && !inExpr
+      const leafArt = column.$refLinks[column.$refLinks.length - 1].definition
+      const virtual = (leafArt.virtual || !isPersisted) && !inExpr
       // check if we need to merge the column `ref` into the join tree of the query
-      if (!inExists && !virtual && isColumnJoinRelevant(column)) {
+      if (!inExists && !virtual && !inCalcElement && isColumnJoinRelevant(column, firstStepIsSelf)) {
+        if (originalQuery.UPDATE)
+          throw cds.error(
+            'Path expressions for UPDATE statements are not supported. Use “where exists” with infix filters instead.',
+          )
         Object.defineProperty(column, 'isJoinRelevant', { value: true })
-        joinTree.mergeColumn(column)
+        joinTree.mergeColumn(column, $baseLink)
+      }
+      if (leafArt.value && !leafArt.value.stored) {
+        resolveCalculatedElement(leafArt, column)
       }
 
       /**
        * Resolves and processes the inline attribute of a column in a database query.
        *
-       * @param {Object} col - The column object with properties: `inline` and `$refLinks`.
+       * @param {object} col - The column object with properties: `inline` and `$refLinks`.
        * @param {string} [namePrefix=col.as || col.flatName] - Prefix for naming new columns. Defaults to `col.as` or `col.flatName`.
-       * @returns {Object} - An object with resolved and processed inline column definitions.
+       * @returns {object} - An object with resolved and processed inline column definitions.
        *
        * Procedure:
        * 1. Iterate through `inline` array. For each `inlineCol`:
@@ -650,8 +728,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
       /**
        * Resolves a query column which has an `expand` property.
        *
-       * @param {Object} col - The column object with properties: `expand` and `$refLinks`.
-       * @returns {Object} - A `cds.struct` object with expanded column definitions.
+       * @param {object} col - The column object with properties: `expand` and `$refLinks`.
+       * @returns {object} - A `cds.struct` object with expanded column definitions.
        *
        * Procedure:
        * - if `$leafLink` is an association, constructs an `expandSubquery` and infers a new query structure.
@@ -717,6 +795,58 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         throw new Error(err)
       }
     }
+    function resolveCalculatedElement(calcElement) {
+      if (alreadySeenCalcElements.has(calcElement)) return
+      else alreadySeenCalcElements.add(calcElement)
+      const { ref, xpr, func } = calcElement.value
+      if (ref || xpr) {
+        attachRefLinksToArg(calcElement.value, { definition: calcElement.parent, target: calcElement.parent }, true)
+        // column is now fully linked, now we need to find out if we need to merge it into the join tree
+        // for that, we calculate all paths from a calc element and merge them into the join tree
+        mergePathsIntoJoinTree(calcElement.value)
+      }
+      if (func) calcElement.value.args?.forEach(arg => inferQueryElement(arg, false)) // {func}.args are optional
+      function mergePathsIntoJoinTree(e, basePath = null) {
+        basePath = basePath || { $refLinks: [], ref: [] }
+        if (e.ref) {
+          e.$refLinks.forEach((link, i) => {
+            const { definition } = link
+            if (!definition.value) {
+              basePath.$refLinks.push(link)
+              basePath.ref.push(e.ref[i])
+            }
+          })
+          const leafOfCalculatedElementRef = e.$refLinks[e.$refLinks.length - 1].definition
+          if (leafOfCalculatedElementRef.value) mergePathsIntoJoinTree(leafOfCalculatedElementRef.value, basePath)
+
+          mergePathIfNecessary(basePath, e)
+        } else if (e.xpr) {
+          e.xpr.forEach(step => {
+            if (step.ref) {
+              const subPath = { $refLinks: [...basePath.$refLinks], ref: [...basePath.ref] }
+              step.$refLinks.forEach((link, i) => {
+                const { definition } = link
+                if (definition.value) {
+                  mergePathsIntoJoinTree(definition.value)
+                } else {
+                  subPath.$refLinks.push(link)
+                  subPath.ref.push(step.ref[i])
+                }
+              })
+              mergePathIfNecessary(subPath, step)
+            }
+          })
+        }
+
+        function mergePathIfNecessary(p, step) {
+          const calcElementIsJoinRelevant = isColumnJoinRelevant(p)
+          if (calcElementIsJoinRelevant) {
+            if (!calcElement.value.isColumnJoinRelevant) Object.defineProperty(step, 'isJoinRelevant', { value: true })
+            joinTree.mergeColumn(p)
+          }
+        }
+      }
+    }
 
     /**
      * Checks whether or not the `ref` of the given column is join relevant.
@@ -760,7 +890,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
       if (!assoc) return false
       if (fkAccess) return false
-      else return true
+      return true
     }
 
     /**
@@ -768,15 +898,20 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
      * if there is not already an element with the same name present.
      */
     function inferElementsFromWildCard() {
+      const exclude = _.excluding ? x => _.excluding.includes(x) : () => false
+
       if (Object.keys(queryElements).length === 0 && aliases.length === 1) {
         // only one query source and no overwritten columns
         Object.entries(sources[aliases[0]].elements).forEach(([name, element]) => {
-          if (element.type !== 'cds.LargeBinary') queryElements[name] = element
+          if (!exclude(name) && element.type !== 'cds.LargeBinary') queryElements[name] = element
+          if (element.value) {
+            // we might have join relevant calculated elements
+            resolveCalculatedElement(element)
+          }
         })
         return
       }
 
-      const exclude = _.excluding ? x => _.excluding.includes(x) : () => false
       const ambiguousElements = {}
       Object.entries($combinedElements).forEach(([name, tableAliases]) => {
         if (Object.keys(tableAliases).length > 1) {

package/lib/infer/join-tree.js

@@ -1,50 +1,92 @@
 'use strict'
 
+// REVISIT: define following unknown types
+
+/**
+ * @typedef {unknown} $refLink
+ */
+
+/**
+ * @typedef {unknown} parent
+ */
+
+/**
+ * @typedef {unknown} where
+ */
+
+/**
+ * @typedef {unknown} children
+ */
+
+/**
+ * @typedef {unknown} queryArtifact
+ */
+
+/**
+ * @typedef {string} alias
+ */
+
+/**
+ * @typedef {Map<alias,Root>} _roots
+ */
+
+/**
+ * @typedef {Object.<string, unknown>} sources
+ */
+
 /**
  * A class representing a Node in the join tree.
- *
- * @property {$refLink} - A reference link to this node.
- * @property {parent} - The parent Node of this node.
- * @property {where} - An optional condition to be applied to this node.
- * @property {children} - A Map of children nodes belonging to this node.
  */
 class Node {
+  /**
+   * @param {$refLink} $refLink
+   * @param {parent} parent
+   * @param {where} where
+   */
   constructor($refLink, parent, where = null) {
+    /** @type {$refLink} - A reference link to this node. */
     this.$refLink = $refLink
+    /** @type {parent} - The parent Node of this node. */
     this.parent = parent
+    /** @type {where} - An optional condition to be applied to this node. */
     this.where = where
+    /** @type {children} - A Map of children nodes belonging to this node. */
     this.children = new Map()
   }
 }
 
 /**
  * A class representing the root of the join tree.
- *
- * @property {queryArtifact} - The artifact used to make the query.
- * @property {alias} - The alias of the artifact.
- * @property {parent} - The parent Node of this root, null for the root Node.
- * @property {children} - A Map of children nodes belonging to this root.
  */
 class Root {
+  /**
+   * @param {[alias, queryArtifact]} querySource
+   */
   constructor(querySource) {
     const [alias, queryArtifact] = querySource
+    /** @type {queryArtifact} - The artifact used to make the query. */
     this.queryArtifact = queryArtifact
+    /** @type {alias} - The alias of the artifact. */
     this.alias = alias
+    /** @type {parent} - The parent Node of this root, null for the root Node. */
     this.parent = null
+    /** @type {children} - A Map of children nodes belonging to this root. */
     this.children = new Map()
   }
 }
 
 /**
  * A class representing a Join Tree.
- *
- * @property {_roots} - A Map of root nodes.
- * @property {isInitial} - A boolean indicating if the join tree is in its initial state.
- * @property {_queryAliases} - A Map of query aliases, which is used during the association to join translation.
  */
 class JoinTree {
+  /**
+   *
+   * @param {sources} sources
+   */
   constructor(sources) {
+    /** @type {_roots} - A Map of root nodes. */
     this._roots = new Map()
+    /** @type {boolean} - A boolean indicating if the join tree is in its initial state. */
     this.isInitial = true
     /**
      * A map that holds query aliases which are used during the
@@ -53,6 +95,7 @@ class JoinTree {
      *
      * The table aliases are treated case insensitive. The index of each
      * table alias entry, is the capitalized version of the alias.
+     * @type {Map<string, string>}
      */
     this._queryAliases = new Map()
     Object.entries(sources).forEach(entry => {
@@ -82,6 +125,7 @@ class JoinTree {
    * Calculates and adds the next available table alias to the alias map.
    *
    * @param {string} alias - The original alias name.
+   * @param {unknown[]} outerQueries - An array of outer queries.
    * @returns {string} - The next unambiguous table alias.
    */
   addNextAvailableTableAlias(alias, outerQueries) {
@@ -107,7 +151,7 @@ class JoinTree {
    * For each step, it checks whether it has been seen before. If so, it resets the $refLink to point to the already merged $refLink.
    * If not, it creates a new Node and ensures proper aliasing and foreign key access.
    *
-   * @param {Object} col - The column object to be merged into the existing join tree. This object should have the properties $refLinks and ref.
+   * @param {object} col - The column object to be merged into the existing join tree. This object should have the properties $refLinks and ref.
    * @returns {boolean} - Always returns true, indicating the column has been successfully merged into the join tree.
    */
   mergeColumn(col) {
@@ -145,8 +189,9 @@ class JoinTree {
         }
         const child = new Node($refLink, node, where)
         if (child.$refLink.definition.isAssociation) {
-          if (child.where) {
-            // always join relevant
+          if (child.where || col.inline) {
+            // filter is always join relevant
+            // if the column ends up in an `inline` -> each assoc step is join relevant
             child.$refLink.onlyForeignKeyAccess = false
           } else {
             child.$refLink.onlyForeignKeyAccess = true

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "CDS base database service",
-  "homepage": "https://cap.cloud.sap/",
+  "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cap-js/cds-dbs"
+  },
+  "bugs": {
+    "url": "https://github.com/cap-js/cds-dbs/issues"
+  },
   "keywords": [
     "CAP",
     "CDS"
   ],
   "author": "SAP SE (https://www.sap.com)",
   "main": "index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "lib",
     "CHANGELOG.md"
@@ -19,12 +27,16 @@
   },
   "scripts": {
     "prettier": "npx prettier --write .",
-    "test": "npx jest --silent",
+    "test": "npm run build && npx jest --silent",
+    "build": "tsc && find lib/ -type f -name '*.d.ts' -exec cp '{}' 'dist/{}' ';' && cp ts.eslintrc.cjs dist/.eslintrc.cjs && npx eslint ./dist --ext .d.ts",
     "lint": "npx eslint . && npx prettier --check . "
   },
-  "dependencies": {},
   "peerDependencies": {
-    "@sap/cds": ">=7"
+    "@sap/cds": ">=7.1.1"
   },
-  "license": "SEE LICENSE"
+  "license": "SEE LICENSE",
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^6.2.0",
+    "typescript": "^5.1.6"
+  }
 }