@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/transform/odata/typesExposure.js

@@ -8,7 +8,7 @@
 
 const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember } = require('../../model/csnUtils');
+const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
 const { copyAnnotations } = require('../../model/csnUtils');
 const { isBetaEnabled } = require('../../base/model.js');
 
@@ -49,6 +49,31 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     }
   });
 
+  if(isBetaEnabled(options, 'odataTerms')) {
+    forEachGeneric(csn, 'vocabularies', (def, defName, _propertyName, path) => {
+    // we do expose types only for definition from inside services
+      const serviceName = whatsMyServiceName(defName, false);
+    // run type exposure only on requested services if not in multi schema mode
+    // multi schema mode requires a proper type exposure for all services as a prerequisite
+    // for the proxy exposure
+      if (serviceName && requestedServiceNames.includes(serviceName)) {
+        if(csn.definitions[defName]) {
+        // error, duplicate definitions not allowed!
+        // TODO: Use path as error location as soon as refs outside definitions are supported
+          error('odata-definition-exists', ['vocabularies', defName], { anno: defName, '#':'anno' });
+        }
+        else {
+        // link def into definitions for later use
+          def.kind = 'annotation';
+          csn.definitions[defName] = def;
+          const artificialName = `term_${defName.replace(/\./g, '_')}`;//_${paramName}`;
+          const newTypeName = getNewTypeName(undefined, undefined, artificialName, serviceName);
+          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, path.concat(['vocabularies', defName]), undefined, true);
+        }
+      }
+    });
+  }
+
   return schemas;
 
 /**
@@ -82,14 +107,14 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} serviceName
    * @param {String} newTypeName
    */
-  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName) {
-    const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable(node);
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName, isTermDef=false) {
+    const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable();
     if (isExposable) {
       // this is the name used to register the new type in csn.definitions
       let fullQualifiedNewTypeName =
         isMultiSchema
-          ? (node.type || (node.items && node.items.type)
-              ? getTypeNameInMultiSchema(node.type|| (node.items && node.items.type), serviceName)
+          ? (node.type || (node.items?.type)
+              ? getTypeNameInMultiSchema(node.type|| (node.items?.type), serviceName)
               : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
           : `${serviceName}.${newTypeName}`;
 
@@ -100,7 +125,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           isKey = false;
         // in case this was a named type and if the openess does not match the type definition
         // expose the type as a new one not changing the original definition.
-        if((!!node['@open'] !== !!typeDef['@open']) && isBetaEnabled(options, 'odataOpenType'))
+        if(elements && (!!node['@open'] !== !!typeDef['@open']) && isBetaEnabled(options, 'odataOpenType'))
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
       }
       // check if that type is already defined
@@ -118,51 +143,62 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         /* Expose new structured type
          * Treat items.elements as ordinary elements for now.
          */
-        newType = createNewStructType(elements);
-        // if using node enforces open/closed, set it on type
-        if(node['@open'] !== undefined)
-          newType['@open'] = node['@open']
-        if (node.$location)
-          setProp(newType, '$location', node.$location);
+        if(elements) {
+          newType = createNewStructType(elements);
+          // if using node enforces open/closed, set it on type
+          if(node['@open'] !== undefined)
+            newType['@open'] = node['@open']
+          if (node.$location)
+            setProp(newType, '$location', node.$location);
 
-        csn.definitions[fullQualifiedNewTypeName] = newType;
-        exposedTypes[fullQualifiedNewTypeName] = 1;
+          csn.definitions[fullQualifiedNewTypeName] = newType;
+          exposedTypes[fullQualifiedNewTypeName] = 1;
 
-        // Recurse into elements of 'type' (if any) and expose them as well (is needed)
-        newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
-          if (node.elements && node.elements[elemName].$location)
-            setProp(newElem, '$location', node.elements[elemName].$location);
-          defName = typeDef.kind === 'type' ? typeName : defName;
-          {
-            const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
-                           getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName);
-            // if the type for the newElem was not exposed it may be a scalar type def from an external service that hasn't
-            // been catched by expandToFinalBaseType() (forODataNew must not modify external imported services)
-            if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
-              if(typeDef.items) {
-                newElem.items = typeDef.items;
-                delete newElem.type;
-              }
-              else if(newElem.items) {
-                newElem.items.type = typeName;
-                if(typeDef.enum)
-                  newElem.items.enum = typeDef.enum;
-              }
-              else {
-                newElem.type = typeName;
-                if(typeDef.enum)
-                  newElem.enum = typeDef.enum;
+          // Recurse into elements of 'type' (if any) and expose them as well (is needed)
+          newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
+            if (node.elements && node.elements[elemName].$location)
+              setProp(newElem, '$location', node.elements[elemName].$location);
+            defName = typeDef.kind === 'type' ? typeName : defName;
+            {
+              const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
+                            getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName, isTermDef);
+              // if the type for the newElem was not exposed it may be a scalar type def from an external service that hasn't
+              // been catched by expandToFinalBaseType() (forODataNew must not modify external imported services)
+              if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
+                if(typeDef.items) {
+                  newElem.items = typeDef.items;
+                  delete newElem.type;
+                }
+                else if(newElem.items) {
+                  newElem.items.type = typeName;
+                  if(typeDef.enum)
+                    newElem.items.enum = typeDef.enum;
+                }
+                else {
+                  newElem.type = typeName;
+                  if(typeDef.enum)
+                    newElem.enum = typeDef.enum;
+                }
               }
             }
+          });
+          copyAnnotations(typeDef, newType);
+          // if the origin type had items, add items to exposed type
+          if(typeDef.kind === 'type') {
+            if(typeDef.items) {
+              newType.items = { elements: newType.elements };
+              delete newType.elements;
+            }
           }
-        });
-        copyAnnotations(typeDef, newType);
-        // if the origin type had items, add items to exposed type
-        if(typeDef.kind === 'type') {
-          if(typeDef.items) {
-            newType.items = { elements: newType.elements };
-            delete newType.elements;
+        }
+        else if(isTermDef) {
+          newType = Object.create(null);
+          for(let n in typeDef) {
+            newType[n] = typeDef[n];
           }
+          newType.kind = 'type';
+          csn.definitions[fullQualifiedNewTypeName] = newType;
+          exposedTypes[fullQualifiedNewTypeName] = 1;
         }
       }
       // adjust current node to new type
@@ -188,36 +224,44 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
      *  - the elements dictionary that needs to be cloned
      *  - the typeDef, either the resolved type def or the node itself
      *  - if structured type was anonymously defined
-     * @param {object} node
      * @returns {object} { isExposable, typeDef, typeName, elements, isAnonymous }
      */
-    function isTypeExposable(node) {
+    function isTypeExposable() {
       let typeName = undefined;
       let typeDef = node;
-      let elements = (node.items && node.items.elements || node.elements)
+      let elements = (node.items?.elements || node.elements)
       // anonymous structured type
       if(elements)
         return { isExposable: true, typeDef, typeName, elements, isAnonymous: true };
       // named type, resolve the type to inspect it
-      let type = node.items && node.items.type || node.type;
+      let type = node.items?.type || node.type;
       if(type) {
         typeName = (type.ref && csnUtils.getFinalType(type)) || type;
-        typeDef = csnUtils.getFinalTypeDef(typeName);
         const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
-        if(!isBuiltinType(typeName) && !isArtifactInService(typeName, serviceName)) {
-          while(!isBuiltinType(typeName)) {
-            typeDef = csnUtils.getFinalTypeDef(typeName);
-            if(typeDef) {
-              if((rc.elements = (typeDef.items && typeDef.items.elements || typeDef.elements)) !== undefined)
-                return rc;
-              type = typeDef.items && typeDef.items.type || typeDef.type;
-              typeName = (type.ref && csnUtils.getFinalType(type)) || type;
-            }
-            else {
-              throw Error(`Please debug me: ${typeName} not found`);
+        if(!isBuiltinType(typeName)) {
+          rc.typeDef = typeDef = csnUtils.getFinalTypeDef(typeName);
+          if(!isArtifactInService(typeName, serviceName)) {
+            while(!isBuiltinType(typeName)) {
+              typeDef = csnUtils.getFinalTypeDef(typeName);
+              if(typeDef) {
+                if((isTermDef && typeDef.enum) || (rc.elements = (typeDef.items?.elements || typeDef.elements)) !== undefined)
+                  return rc;
+                type = typeDef.items?.type || typeDef.type;
+                typeName = (type.ref && csnUtils.getFinalType(type)) || type;
+              }
+              else {
+                throw Error(`Please debug me: ${typeName} not found`);
+              }
             }
           }
+          else {
+            rc.isExposable = false;
+            return rc;
+          }
         }
+        // else if(isTermDef && typeDef.enum) {
+        //   return rc;
+        // }
       }
       return { isExposable: false, typeDef, typeName, isAnonymous: false };
     }
@@ -308,7 +352,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
   */
   function getNewTypeName(element, elementName, typeNamePrefix, serviceName) {
     // for the new type name node.type has precedence over node.items.type
-    const typeName = (!element.elements && element.type || element.items && !element.items.elements && element.items.type);
+    const typeName = (!element?.elements && element?.type || !element?.items?.elements && element?.items?.type);
     return typeName
         ? `${isMultiSchema
               ? typeName.split('.').pop() // use leaf element

package/lib/transform/parseExpr.js

@@ -1,11 +1,17 @@
+// @ts-nocheck
+
 'use strict'
 
+// const funkyfuncs = Object.keys(require('../compiler/builtins.js').
+//   specialFunctions).filter(n => n.length).map(n=>n.toLowerCase());
+
 /**
- * parseExpr accepts any JSON object and tries to convert a token stream expression
+ * parseExpr() accepts any JSON object and tries to convert a token stream expression
  * array into an AST like expression with CDL operator precedence.
  *
  * The following operators are supported:
  *
+ * Unary:                      +/-
  * Multiplication/Division:    '*', '/'
  * Addition/Subtraction:       '+', '-'
  * Concatenation:              '||'
@@ -13,7 +19,7 @@
  * Unary:                      'is [not] null', 'not'
  * Conditional:                'case [when then]+ [else]? end', 'and', 'or'
  *
- * Not yet implmemented:       'new'
+ * Not yet implemented:        'new'
  *
  * This is not an optimized LL(1) parser but a token 'sniffer'. A stream is
  * cracked up in sub streams and passed down to the next higher function.
@@ -27,95 +33,122 @@
  * This parser intentionally does no error handling. If a clause is malformed, it is accepted as is.
  *
  * @param {any} xpr A JSON object.
- * @param {Boolean} array Bias AST representation.
+ * @param {Object} state Objet
+ *  anno: Don't eliminate arrays with single entry in statetations as they are collections
+ *  array: Bias AST representation.
+ *  nary: return n-ary or binary tree
  */
 
-function parseExpr(xpr, array=true) {
-  return parseExprInt(xpr);
+function parseExpr(xpr, state = { anno: 0, array: true, nary: true }) {
+  // Notes:
+  //  - Variables `s` and `e` are used as index variables into `xpr`s for start and end.
+  //  - xpr's are our CSN expressions, see <https://pages.github.tools.sap/cap/docs/cds/cxn>
+
+  return parseExprInt(xpr, state);
 
-  function parseExprInt(xpr) {
-    return conditionOR(...CaseWhen(xpr));
+  function parseExprInt(xpr, state) {
+    return conditionOR(...CaseWhen(xpr), state);
   }
 
   function CaseWhen(xpr) {
-    if(Array.isArray(xpr))
-      inner(xpr);
+    if(Array.isArray(xpr)) {
+      recurseIntoCases();
+    }
     return [xpr, 0, Array.isArray(xpr) ? xpr.length : 1];
 
-    // replace case/end from inner to outer
-    function inner(pxpr, lvl=0) {
-      const s = pxpr.findIndex(t => t === 'case');
-      if(s >= 0) {
-        let e = findLastIndex(pxpr, 'end');
-        pxpr = pxpr.slice(s+1, e);
-        const dist = inner(pxpr, lvl+1);
-        e -= dist;
-        if(dist > 0)
-          pxpr = xpr.slice(s+1, e+1);
-        const caseTree = array ? [ 'case' ] : { 'case': [] };
-        let i = pxpr.findIndex(t => t === 'else');
-        let elseCond = undefined;
-        if(i >= 0) {
-          elseCond = pxpr.slice(i+1);
-          pxpr = pxpr.slice(0, i);
+    function recurseIntoCases(casePos=-1, lvl=-1) {
+      for(let c = casePos+1; c < xpr.length; c++) {
+        if(xpr[c] === 'case') {
+          recurseIntoCases(c, lvl+1)
         }
-        i = pxpr.findIndex(t => t === 'when');
-        while(i >= 0) {
-          pxpr = pxpr.slice(i+1);
-          const when = { 'when': [] };
-          if(array)
-            caseTree.push('when');
-          else
-            caseTree.case.push(when);
-          i = pxpr.findIndex(t => t === 'then');
-          if(i >= 0) {
-            const arg = pxpr.slice(0, i);
-            if(array)
-              caseTree.push(arg);
-            else
-              when.when.push(arg.length === 1 ? arg[0] : arg);
-          }
-          pxpr = pxpr.slice(i+1);
-          i = pxpr.findIndex(t => t === 'when');
-          const arg = ((i >= 0) ? pxpr.slice(0, i) : pxpr);
-          if(array)
-            caseTree.push('then', arg);
+      }
+      if(lvl > -1) {
+        let endPos = casePos;
+        while(xpr[endPos] !== 'end' && endPos < xpr.length) endPos++;
+        if(xpr[endPos] === 'end') {
+          const caseTree = rewriteCaseBlock(casePos, endPos);
+          if(casePos === 0 && endPos === xpr.length-1)
+            xpr = caseTree;
           else
-            when.when.push(arg.length === 1 ? arg[0] : arg);
+            xpr.splice(casePos, endPos-casePos+1, caseTree);
         }
-        if(elseCond) {
-          if(array)
-            caseTree.push('else', elseCond);
+      }
+    }
+
+    /**
+     * @param {number} casePos
+     * @param {number} endPos
+     * @return {Array|object}
+     */
+    function rewriteCaseBlock(casePos, endPos) {
+      const caseTree = state.array ? [ 'case' ] : { 'case': [] };
+      
+      let elsePos = endPos;
+      let whenPos = casePos;
+
+      while(xpr[elsePos] !== 'else' && elsePos > casePos) elsePos--;
+      let elseCond = undefined;
+      if(xpr[elsePos] === 'else') {
+        elseCond = xpr.slice(elsePos+1, endPos);
+        endPos = elsePos;
+      }
+
+      while(xpr[whenPos] !== 'when' && whenPos < endPos) whenPos++;
+      if(xpr[whenPos] === 'when' && whenPos - (casePos+1) >= 1) {
+        const arg = xpr.slice(casePos+1, whenPos)
+        if(state.array)
+          caseTree.push(arg);
+        else
+            caseTree.case.push(arg);
+      }
+
+      while(xpr[whenPos] === 'when') {
+        const when = { 'when': [] };
+        if(state.array)
+          caseTree.push('when');
+        else
+          caseTree.case.push(when);
+
+        let thenPos = whenPos+1;
+        while(xpr[thenPos] !== 'then' && thenPos < endPos) thenPos++;
+        if(xpr[thenPos] === 'then') {
+          const when = xpr.slice(whenPos+1, thenPos);
+          if(state.array)
+            caseTree.push(when);
           else
-            caseTree.case.push(elseCond.length === 1 ? elseCond[0] : elseCond);
+            when.when.push(when.length === 1 ? when[0] : when);
         }
-        if(array)
-          caseTree.push('end');
-        if(lvl > 0)
-          xpr.splice(s+1, e-s+1, caseTree);
-        else {
-          xpr = caseTree;
+
+        whenPos = thenPos+1;
+        while(xpr[whenPos] !== 'when' && whenPos < endPos) whenPos++;
+        if(xpr[whenPos] === 'when' || whenPos === endPos) {
+          const then = xpr.slice(thenPos+1, whenPos);
+          if(state.array)
+            caseTree.push('then', then);
+          else
+            when.when.push(then.length === 1 ? then[0] : then);
         }
-        return e-s+1;
       }
-      else
-        return 0;
-    }
-
-    function findLastIndex(expr, token, l=expr.length-1) {
-      while(l >= 0 && expr[l] !== token) l--;
-      return l;
+      if(elseCond) {
+        if(state.array)
+          caseTree.push('else', elseCond);
+        else
+            caseTree.case.push(elseCond.length === 1 ? elseCond[0] : elseCond);
+      }
+      if(state.array)
+        caseTree.push('end');
+      return caseTree;
     }
   }
 
-  function conditionOR(xpr, s, e) {
-    return binaryExpr(xpr, ['or'], conditionAnd, s, e);
+  function conditionOR(xpr, s, e, state) {
+    return binaryExpr(xpr, ['or'], conditionAnd, s, e, state);
   }
-  function conditionAnd(xpr, s, e) {
+  
+  function conditionAnd(xpr, s, e, state) {
     return binaryExpr(xpr, (xpr, s, e) => {
       let a = s-1;
       let b;
-      // scan for 'and', skip 'between/and'
       do {
         b = false;
         for(a++; xpr[a] !== 'and' && a < e; a++) {
@@ -128,26 +161,31 @@ function parseExpr(xpr, array=true) {
         return [1, a]
       else
         return [1, -1];
-    }, conditionTerm, s, e);
+    }, conditionTerm, s, e, state);
   }
 
-  function conditionTerm(xpr, s, e) {
+  function conditionTerm(xpr, s, e, state) {
     if(Array.isArray(xpr)) {
       if(xpr.length >= 3 && xpr[s+1] === 'is') {
+        const isnull = conditionOR(xpr[s], state);
         if(xpr[s+2] === 'null')
-          return array ? [ conditionOR(xpr[s]), 'is', 'null' ] :  { 'isNull': conditionOR(xpr[s]) };
+          return state.array ? [ isnull, 'is', 'null' ] :  { 'isNull': isnull };
         else if(xpr[s+2] === 'not' && xpr[s+3] === 'null')
-          return array ? [ conditionOR(xpr[s]), 'is', 'not', 'null' ] : { 'isNotNull': conditionOR(xpr[s]) };
+          return state.array ? [ isnull, 'is', 'not', 'null' ] : { 'isNotNull': isnull };
+      }
+      if(xpr[s] === 'not') {
+        const  not = conditionTerm(xpr, s+1, e, state)
+        return state.array ? [ 'not',  not ] : { 'not':  not };
+      }
+      if(xpr[s] === 'exists') {
+        const exists = conditionTerm(xpr, s+1, e, state)
+        return state.array ? [ 'exists', exists ] : { 'exists': exists };
       }
-      if(xpr[s] === 'not')
-        return array ? [ 'not', conditionTerm(xpr, s+1, e) ] : { 'not': conditionTerm(xpr, s+1, e) };
-      if(xpr[s] === 'exists')
-        return array ? [ 'exists', conditionOR(xpr[s+1]) ] : { 'exists': conditionOR(xpr[s+1]) };
     }
-    return compareTerm(xpr, s, e);
+    return compareTerm(xpr, s, e, state);
   }
 
-  function compareTerm(xpr, s, e) {
+  function compareTerm(xpr, s, e, state) {
     if(Array.isArray(xpr)) {
       let i = s;
       while(i < e && xpr[i] !== 'between') i++;
@@ -155,20 +193,26 @@ function parseExpr(xpr, array=true) {
       while(i < e && xpr[i] !== 'and') i++;
       const a = i < e ? i : -1;
       if(b >= 0) {
-        const expr = expression(xpr, s, b);
-        const between = array ? [ expr, 'between' ] : { 'between': [ expr ] };
+        let token = [ 'between' ];
+        const not = (xpr[b-1] === 'not');
+        if(not)
+          token.splice(0,0, 'not');
+        const expr = expression(xpr, s, not ? b-1 : b, state);
+        const between = state.array
+          ? [ expr, ...token ]
+          : { 'between': [ expr ] };
         if(a >= 0) {
-          const lower = expression(xpr, b+1, a);
-          const upper = expression(xpr, a+1, e);
-          if(array)
+          const lower = expression(xpr, b+1, a, state);
+          const upper = expression(xpr, a+1, e, state);
+          if(state.array)
             between.push(lower, 'and', upper);
           else {
             between.between.push(lower, upper);
           }
         }
         else {
-          const unspec = expression(xpr, b+1, e);
-          if(array)
+          const unspec = expression(xpr, b+1, e, state);
+          if(state.array)
             between.push(unspec);
           else
             between.between.push(unspec);
@@ -176,55 +220,114 @@ function parseExpr(xpr, array=true) {
         return between;
       }
     }
-    return binaryExpr(xpr, ['=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in'], expression, s, e);
+    return binaryExpr(xpr, (xpr, s, e) => {
+      const token = ['=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in'];
+      while(s < e && !token.includes(xpr[s])) s++;
+      if(s < e) {
+        if(xpr[s-1] === 'not' && (xpr[s] === 'in' || xpr[s] === 'like'))
+          return [2, s-1];
+        else
+          return [1, s];
+      }
+      return [1, -1];
+    }, expression, s, e, state);
   }
 
-  function expression(xpr, s, e) {
-    return binaryExpr(xpr, ['||'], exprAddSub, s, e);
+  function expression(xpr, s, e, state) {
+    return binaryExpr(xpr, ['||'], exprAddSub, s, e, state);
   }
 
-  function exprAddSub(xpr, s, e) {
-    return binaryExpr(xpr, ['+', '-'], exprMulDiv, s, e);
+  function exprAddSub(xpr, s, e, state) {
+    return binaryExpr(xpr, (xpr, s, e) => {
+      const skips = [ '+', '-', '*', '/' ];
+      let found = false;
+      let p=s;
+      while(!found && p < e) {
+        found = ((xpr[p] === '+' || xpr[p] === '-') && p > s && !skips.includes(xpr[p-1]) && p < e);
+        if(!found) p++;
+      }
+      if(found)
+        return [1, p];
+      return [1, -1];
+    }, exprMulDiv, s, e, state);
+  }
+
+  function exprMulDiv(xpr, s, e, state) {
+    return binaryExpr(xpr, ['*', '/'], unary, s, e, state);
   }
 
-  function exprMulDiv(xpr, s, e) {
-    return binaryExpr(xpr, ['*', '/'], terminal, s, e);
+  function unary(xpr, s, e, state) {
+    if(Array.isArray(xpr)) {
+      if(xpr[s] === '+' || xpr[s] === '-') {
+        return [ xpr[s], unary(xpr, s+1, e, state) ];
+      }
+    }
+    return terminal(xpr, s, e, state);
   }
+  function terminal(xpr, s, e, state) {
+    const csnarray = [
+      'ref', 'args', 'columns', 'keys', 'expand', 'inline',
+      'requires', 'extensions', 'includes', 'excluding'
+    ];
+    const xprarray = [
+      'xpr', 'on', 'where', 'orderBy', 'groupBy', 'having' ];
 
-  function terminal(xpr, s, e) {
     if(Array.isArray(xpr) && xpr.length > 0) {
-      if(e-s <= 1)
-        return parseExprInt(xpr[e-1]);
+      if(e-s <= 1 && state.anno === 0)
+        return parseExprInt(xpr[e-1], state);
       else
-        return xpr.slice(s, e).map(parseExprInt);
+        return xpr.slice(s, e).map(ix => parseExprInt(ix, state));
     }
     if (typeof xpr === 'object') {
+      // if(xpr?.func && funkyfuncs.includes(xpr?.func))
+      //   return xpr;
       for(let n in xpr) {
-        xpr[n] = parseExprInt(xpr[n]);
+        const x = xpr[n];
+        if(n[0] === '@')
+          state.anno++;
+        if(Array.isArray(x)) {
+          if(csnarray.includes(n) || state.anno !== 0)
+            xpr[n] = x.map(ix => parseExprInt(ix, state));
+          else if(xprarray.includes(n) && x.length === 1)
+            xpr[n] = x.map(ix => parseExprInt(ix, state));
+          else
+            xpr[n] = parseExprInt(x, state);
+        }
+        else
+          xpr[n] = parseExprInt(x, state);
+        if(n[0] === '@')
+          state.anno--;
       }
     }
     return xpr;
   }
 
-  function binaryExpr(xpr, token, next, s, e) {
+  function binaryExpr(xpr, token, next, s, e, state) {
+    const expr = [];
     if (Array.isArray(xpr)) {
       let [tl, p] = findToken(s, e);
       if (p >= 0) {
-        let lhs = next(xpr, s, p);
-        let op = xpr[p];
+        let lhs = next(xpr, s, p, state);
+        expr.push(lhs);
+        let op = xpr.slice(p, p+tl);
         s = p+tl;
         [tl, p] = findToken(s, e);
         while(p >= 0) {
-          let rhs = next(xpr, s, p);
-          lhs = array ? [ lhs, op, rhs ] : { [op]: [lhs, rhs] };
-          op = xpr[p];
+          let rhs = next(xpr, s, p, state);
+          expr.push(...op, rhs);
+          lhs = state.array ? [ lhs, ...op, rhs ] : { [op.join('')]: [lhs, rhs] };
+          op = xpr.slice(p, p+tl);
           s = p+tl;
           [tl, p] = findToken(s, e);
         }
-        return array ? [ lhs, op, next(xpr, s, e) ] : { [op]: [lhs, next(xpr, s, e)] };
+        expr.push(...op, next(xpr, s, e, state));
+        if (state.array)
+          return (state.nary ? expr : [ lhs, ...op, next(xpr, s, e, state) ])
+        else
+          return { [op.join('')]: [lhs, next(xpr, s, e, state)] };
       }
     }
-    return next(xpr, s, e);
+    return next(xpr, s, e, state);
 
     function findToken(s, e) {
       if(typeof token === 'function')