@sap/cds-dk 10.1.2 → 10.2.1

package/node_modules/@cap-js/db-service/lib/cqn2pql.js

@@ -22,6 +22,10 @@ class CQN2PQLRenderer extends CQN2SQL {
     return super.column_expr(x, q)
   }
 
+  from_args(args) {
+    return `(${Object.keys(args).map(k => `${k}: ${this.expr(args[k])}`).join(', ')})`
+  }
+
   SELECT_expand(q, sql) { return sql }
 
   INSERT_entries(q) {

package/node_modules/@cap-js/db-service/lib/cqn2sql.js

@@ -579,6 +579,9 @@ class CQN2SQLRenderer {
           distanceVal = where[i]
           where[i] = { val: where[i].val + 1 }
         }
+        else if (c.xpr) {
+          collectDistanceTo(c.xpr, innot)
+        }
       }
     }
 

package/node_modules/@cap-js/db-service/lib/cqn4sql.js

@@ -33,9 +33,6 @@ const notSupportedOps = [['>'], ['<'], ['>='], ['<='], ['*'], ['+'], ['-'], ['/'
 
 const allOps = eqOps.concat(eqOps).concat(notEqOps).concat(notSupportedOps)
 
-
-const { depthGuarded, guardEntry } = require('./recursion-guard')
-
 const { pseudos } = require('./infer/pseudos')
 /**
  * Transforms a CDL style query into SQL-Like CQN:
@@ -58,17 +55,7 @@ const { pseudos } = require('./infer/pseudos')
  * @returns {object} transformedQuery the transformed query
  */
 function cqn4sql(originalQuery, model, useTechnicalAlias = true) {
-  // guardEntry bounds subquery nesting and resets the depth budget per top-level call
-  return guardEntry(_cqn4sql)(originalQuery, model, useTechnicalAlias)
-}
-
-function _cqn4sql(originalQuery, model, useTechnicalAlias = true) {
   const getImplicitAlias = str => _getImplicitAlias(str, useTechnicalAlias)
-  // guard xpr and inline/expand-on-struct nesting
-  // eslint-disable-next-line no-func-assign
-  getTransformedTokenStream = depthGuarded(getTransformedTokenStream)
-  // eslint-disable-next-line no-func-assign
-  nestedProjectionOnStructure = depthGuarded(nestedProjectionOnStructure)
   let inferred = typeof originalQuery === 'string' ? cds.parse.cql(originalQuery) : cds.ql.clone(originalQuery)
   const hasCustomJoins =
     originalQuery.SELECT?.from.args && (!originalQuery.joinTree || originalQuery.joinTree.isInitial)
@@ -198,7 +185,7 @@ function _cqn4sql(originalQuery, model, useTechnicalAlias = true) {
   /**
    * If the target entity is annotated with persistence skip and has an underlying db entity,
    * we treat it as a runtime view and transform it into a CTE.
-   *
+   * 
    * @param {object} transformedQuery - The query object to be transformed.
    * @param {string} model - The data model used for inference and transformation.
    */
@@ -214,10 +201,10 @@ function _cqn4sql(originalQuery, model, useTechnicalAlias = true) {
   }
 
   /**
-   * Recursively call cqn4sql for all nested runtime views to calculate cte and
+   * Recursively call cqn4sql for all nested runtime views to calculate cte and 
    * add it as a with clause to the transformed query.
    * Alias the runtime view with a unique alias and update all references to the runtime view to point to the alias.
-   *
+   * 
    * @param {object} rootDefinition - The root definition of the query. This is used to recursively process nested runtime views.
    * @param {object} transformedQuery - The query object to be transformed.
    * @param {string} model - The data model used for infer and cqn4sql.
@@ -421,8 +408,6 @@ function _cqn4sql(originalQuery, model, useTechnicalAlias = true) {
    */
   function translateAssocsToJoins() {
     let from
-    // guard association-path length
-    const joinForBranch = depthGuarded(_joinForBranch)
     /**
      * remember already seen aliases, do not create a join for them again
      */
@@ -446,7 +431,7 @@ function _cqn4sql(originalQuery, model, useTechnicalAlias = true) {
     })
     return from.args.length > 1 ? from : from.args[0]
 
-    function _joinForBranch(lhs, node) {
+    function joinForBranch(lhs, node) {
       const nextAssoc = inferred.joinTree.findNextAssoc(node)
       if (!nextAssoc || alreadySeen.has(nextAssoc.$refLink.alias)) return lhs.args.length > 1 ? lhs : lhs.args[0]
 
@@ -1035,11 +1020,11 @@ function _cqn4sql(originalQuery, model, useTechnicalAlias = true) {
             const keyName = k.as || k.ref.join('_')
             const fkName = `${elemName}_${keyName}`  // e.g., 'head_id'
             const fkFullName = `${columnAlias}_${fkName}`  // e.g., 'department_head_id'
-
+            
             // Check if this FK is excluded
             if (exclude.some(e => (e.ref?.at(-1) || e.as || e) === fkName)) continue
             if (exclude.some(e => (e.ref?.at(-1) || e.as || e) === fkFullName)) continue
-
+            
             const flatColumn = {
               ref: [joinAlias, fkName],
               as: fkFullName,
@@ -1057,7 +1042,7 @@ function _cqn4sql(originalQuery, model, useTechnicalAlias = true) {
             calcElement.as = fullName
           }
           res.push(calcElement)
-        }
+        }        
         else {
           // Scalar element
           const flatColumn = {
@@ -2970,7 +2955,7 @@ function setElementOnColumns(col, element) {
 
 function getPrimaryKey(entity, tableAlias = null) {
   const primaryKey = []
-  for (const k of Object.keys(entity.elements)) {
+  for (const k in entity.elements) {
     const e = entity.elements[k]
     if (e.key === true && !e.virtual && e.isAssociation !== true) {
       primaryKey.push({ ref: tableAlias ? [tableAlias, e.name] : [e.name] })

package/node_modules/@cap-js/db-service/lib/infer/index.js

@@ -5,19 +5,15 @@ const cds = require('@sap/cds')
 const JoinTree = require('./join-tree')
 const { pseudos } = require('./pseudos')
 const { isCalculatedOnRead, getImplicitAlias, getModelUtils, defineProperty, hasOwnSkip, isRuntimeView } = require('../utils')
-const { depthGuarded, guardEntry } = require('../recursion-guard')
 const cdsTypes = cds.builtin.types
 /**
  * @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, useTechnicalAlias = true) {
+function infer(originalQuery, model, useTechnicalAlias = true) {
   if (!model) throw new Error('Please specify a model')
   const inferred = originalQuery
-  // guard func args / lists / xpr / exists nesting
-  // eslint-disable-next-line no-func-assign
-  inferArg = depthGuarded(inferArg)
 
   const { getDefinition } = getModelUtils(model, originalQuery)
 
@@ -295,23 +291,19 @@ function _infer(originalQuery, model, useTechnicalAlias = true) {
      */
     function walkTokenStream(tokenStream, inXpr = false) {
       let skipJoins
-      const processToken = depthGuarded(walker())
-      tokenStream.forEach(processToken)
-
-      function walker() {
-        return t => {
-          if (t === 'exists') {
-            // no joins for infix filters along `exists <path>`
-            skipJoins = true
-          } else if (t.xpr) {
-            // don't miss an exists within an expression
-            t.xpr.forEach(processToken)
-          } else {
-            inferArg(t, queryElements, null, { inExists: skipJoins, inXpr, inQueryModifier: true })
-            skipJoins = false
-          }
+      const processToken = t => {
+        if (t === 'exists') {
+          // no joins for infix filters along `exists <path>`
+          skipJoins = true
+        } else if (t.xpr) {
+          // don't miss an exists within an expression
+          t.xpr.forEach(processToken)
+        } else {
+          inferArg(t, queryElements, null, { inExists: skipJoins, inXpr, inQueryModifier: true })
+          skipJoins = false
         }
       }
+      tokenStream.forEach(processToken)
     }
     /**
      * Processes references starting with `$self`, which are intended to target other query elements.
@@ -585,6 +577,10 @@ function _infer(originalQuery, model, useTechnicalAlias = true) {
         if ((!definition.target && definition.kind !== 'entity') || (!inFrom && !inCalcElement && danglingFilter))
           throw new Error('A filter can only be provided when navigating along associations')
         if (!inFrom && !arg.expand)defineProperty(arg, 'isJoinRelevant', true)
+        // The filter of an `expand` becomes the `where` of the expand subquery.
+        // Just like `where exists <assoc>[…]` semi-joins, path expressions in it are
+        // resolved via joins inside that subquery, so they must not be rejected here.
+        const filterOfExpand = !!arg.expand
         let skipJoinsForFilter = false
         step.where.forEach(token => {
           if (token === 'exists') {
@@ -595,7 +591,7 @@ function _infer(originalQuery, model, useTechnicalAlias = true) {
             // because they will become part of an EXISTS subquery
             inferArg(token, false, arg.$refLinks[i], {
               ...context,
-              inExists: skipJoinsForFilter || inExists || (inFrom && !danglingFilter),
+              inExists: skipJoinsForFilter || inExists || filterOfExpand || (inFrom && !danglingFilter),
               inXpr: !!token.xpr,
               inInfixFilter: true,
               inFrom,
@@ -605,7 +601,7 @@ function _infer(originalQuery, model, useTechnicalAlias = true) {
               applyToFunctionArgs(token.args, inferArg, [
                 false,
                 arg.$refLinks[i],
-                { inExists: skipJoinsForFilter || inExists || (inFrom && !danglingFilter), inXpr: true, inInfixFilter: true, inFrom },
+                { inExists: skipJoinsForFilter || inExists || filterOfExpand || (inFrom && !danglingFilter), inXpr: true, inInfixFilter: true, inFrom },
               ])
             }
           }
@@ -639,7 +635,7 @@ function _infer(originalQuery, model, useTechnicalAlias = true) {
         } else if (arg.inline && queryElements) {
           const elements = resolveInline(arg)
           for (const elName in elements) {
-            if (queryElements[elName] !== undefined) rejectDuplicatedElement(elName)
+            if (queryElements[elName] !== undefined) rejectDuplicatedElement(elName)  
           }
           Object.assign(queryElements, elements)
         } else {
@@ -675,7 +671,7 @@ function _infer(originalQuery, model, useTechnicalAlias = true) {
     // ignore whole expand if target of assoc along path has ”@cds.persistence.skip”
     if (arg.expand) {
       const { $refLinks } = arg
-
+      
       const skip = $refLinks.some(link => {
         const def = getDefinition(link.definition.target)
         return hasOwnSkip(def) && !isRuntimeView(def)
@@ -1295,7 +1291,4 @@ function getMainAlias (query) {
   return mainAlias
 }
 
-// guardEntry bounds nested-subquery re-entry (expand, from, set)
-const infer = guardEntry(_infer)
-
 module.exports = infer

package/node_modules/@cap-js/db-service/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {

package/node_modules/@cap-js/openapi/cds-plugin.js

@@ -0,0 +1,12 @@
+const cds = require('@sap/cds')
+
+const { compile, import: openapi } = require('./index')
+
+if (cds.compile?.to) cds.compile.to.openapi = compile
+
+if (cds.import?.from) cds.import.from.openapi = async function (filepath, options = {}) {
+    const src = await cds.utils.read(filepath, 'utf-8')
+    const csn = openapi.openAPI2csn(src)
+    options.inputFileKind = 'rest'
+    return csn
+}

package/node_modules/@cap-js/openapi/index.js

@@ -1,5 +1,7 @@
 const { compileToOpenAPI } = require('./lib/compile');
+const importOpenAPI = require('./lib/import');
 
 module.exports = {
-    compile: compileToOpenAPI
+    compile: compileToOpenAPI,
+    import: importOpenAPI
 }