@sap/cds-compiler 3.5.4 → 3.6.2

package/lib/language/multiLineStringParser.js

@@ -5,6 +5,7 @@ const {
   isWhitespaceCharacterNoNewline,
   cdlNewLineRegEx,
 } = require('./textUtils');
+const { CompilerAssertion } = require('../base/error');
 
 /**
  * Strips and counts the indentation from the given string.
@@ -76,7 +77,7 @@ class MultiLineStringParser {
 
     if (this.str[0] !== '`' || this.str[this.str.length - 1] !== '`')
       // eslint-disable-next-line max-len
-      throw new Error('Invalid multi-line string sequence: Require string to be surrounded by back-ticks!');
+      throw new CompilerAssertion('Invalid multi-line string sequence: Require string to be surrounded by back-ticks!');
 
     this.output = [];
     this.isTextBlock = this.str.startsWith('```');

package/lib/main.d.ts

@@ -236,7 +236,7 @@ declare namespace compiler {
      *
      * Different databases may support different feature sets of SQL.
      * For example, timestamps are handled differently.  Furthermore, "smart-quoting"
-     * is enabled for `sqlite` and `hana`.  This is useful if identifiers
+     * is enabled for all flavors except `plain`.  This is useful if identifiers
      * collide with reserved keywords.
      *
      * - `plain`:
@@ -252,10 +252,20 @@ declare namespace compiler {
      * - `hana`:
      *   Use this SQL dialect for best compatibility with SAP HANA.
      *   "smart-quoting" upper-cases and quotes identifiers.
+     * - `postgres:
+     *   This SQL dialect ensures compatibility with PostgreSQL.
+     *   Does not support `hana.*` types.  Requires `sqlMapping: 'plain'`.
+     *   "smart-quoting" quotes identifiers that are reserved keywords, but does not upper-case them.
+     *   Since v3.3.0
+     * - `h2`
+     *   This SQL dialect ensures compatibility with H2 v2.
+     *   Does not support `hana.*` types.  Requires `sqlMapping: 'plain'`.
+     *   "smart-quoting" quotes identifiers that are reserved keywords and upper-cases them.
+     *   Since v3.4.0
      *
      * @default 'plain'
      */
-    sqlDialect?: string | 'plain' | 'sqlite' | 'hana'
+    sqlDialect?: string | 'plain' | 'sqlite' | 'hana' | 'postgres' | 'h2'
     /**
      * Object containing magic variables.  These magic variables are
      * used as placeholder values.
@@ -686,6 +696,59 @@ declare namespace compiler {
        * Only relevant for element references of path length 1.
        */
       const functions: string[];
+
+      /**
+       * If the given `name` requires brackets in SQL, return an escaped
+       * identifier in brackets.
+       * Otherwise, return the name without brackets.
+       *
+       * Example:
+       *    ```js
+       *    to.cdl.smartId('with ![brackets]')
+       *    // '![with ![brackets]]]'
+       *    to.cdl.smartId('OCCURRENCE', null)
+       *    // 'OCCURRENCE'
+       *    to.cdl.smartId('OCCURRENCE', 'REPLACE_REGEXPR')
+       *    // '![OCCURRENCE]'
+       *    to.cdl.smartId('myid')
+       *    // 'myid'
+       *    ```
+       *
+       * @param name
+       * @param [insideFunction=null]
+       */
+      function smartId(name: string, insideFunction?: string|null) : string;
+      /**
+       * If the given function `name` requires quoting in CDL, return an escaped
+       * function identifier in brackets for CDL.
+       * Otherwise, return the function name without brackets.
+       *
+       * Example:
+       *    ```js
+       *    to.cdl.smartFunctionId('with ![brackets]')
+       *    // '![with ![brackets]]]'
+       *    to.cdl.smartFunctionId('myfunction')
+       *    // 'myfunction'
+       *    ```
+       *
+       * @param name
+       */
+      function smartFunctionId(name: string) : string;
+      /**
+       * Escapes the given name according to the CDL language and puts it
+       * into `![` and `]`, properly escaping all `]` in the identifier.
+       *
+       * Example:
+       *    ```js
+       *    to.cdl.delimitedId('with ![brackets]')
+       *    // '![with ![brackets]]]'
+       *    to.cdl.delimitedId('myid')
+       *    // '![myid]'
+       *    ```
+       *
+       * @param name
+       */
+      function delimitedId(name: string) : string;
     }
 
     /**
@@ -702,8 +765,58 @@ declare namespace compiler {
          */
         const keywords: string[];
       }
+
+      /**
+       * If the given `name` requires quoting for SQL dialect `dialect`,
+       * returns a quoted and escaped identifier for that SQL dialect.
+       * Otherwise, returns the name without quotes.
+       *
+       * Example:
+       *    ```js
+       *    to.sql.smartId('with "quotes"', 'sqlite')
+       *    // '"with ""quotes"""'
+       *    to.sql.smartId('SELECT', 'sqlite')
+       *    // '"SELECT"'
+       *    to.sql.smartId('myid', 'sqlite')
+       *    // 'myid'
+       *    ```
+       *
+       * @param name
+       * @param dialect
+       */
       function smartId(name: string, dialect: string) : string;
+      /**
+       * If the given function `name` requires quoting for SQL dialect `dialect`,
+       * returns a quoted and escaped function identifier for that SQL dialect.
+       * Otherwise, returns the function name without quotes.
+       *
+       * Example:
+       *    ```js
+       *    to.sql.smartFunctionId('with "quotes"', 'sqlite')
+       *    // '"with ""quotes"""'
+       *    to.sql.smartFunctionId('myfunction', 'sqlite')
+       *    // 'myfunction'
+       *    ```
+       *
+       * @param name
+       * @param dialect
+       */
       function smartFunctionId(name: string, dialect: string) : string;
+      /**
+       * Escapes the given name according to the SQL dialect and puts it
+       * into quotes.
+       *
+       * Example:
+       *    ```js
+       *    to.sql.delimitedId('with "quotes"', 'sqlite')
+       *    // '"with ""quotes"""'
+       *    to.sql.delimitedId('myid', 'sqlite')
+       *    // '"myid"'
+       *    ```
+       *
+       * @param name
+       * @param dialect
+       */
       function delimitedId(name: string, dialect: string) : string;
     }
 

package/lib/main.js

@@ -19,6 +19,7 @@ const model_api = lazyload('./model/api');
 const messages = lazyload('./base/messages');
 const sqlIdentifier = lazyload('./sql-identifier');
 const keywords = lazyload( './base/keywords' );
+const toCdl = lazyload('./render/toCdl');
 
 const parseLanguage = lazyload('./language/antlrParser');
 const compiler = lazyload('./compiler');
@@ -106,13 +107,22 @@ module.exports = {
   hasErrors: (...args) => messages.hasErrors(...args),
 
   // additional API:
-  parse: { cdl: (...args) => parseCdl(...args), cql: (...args) => parseCql(...args), expr: (...args) => parseExpr(...args) },
+  parse: {
+    cdl: (...args) => parseCdl(...args),
+    cql: (...args) => parseCql(...args),
+    expr: (...args) => parseExpr(...args)
+  },
   // SNAPI
-  for: { odata: (...args) => snapi.odata(...args) },
+  for: {
+    odata: (...args) => snapi.odata(...args)
+  },
   to: {
     cdl: Object.assign((...args) => snapi.cdl(...args), {
       keywords: Object.freeze([ ...keywords.cdl ] ),
       functions: Object.freeze([ ...keywords.cdl_functions ] ),
+      smartId: (...args) => toCdl.smartId(...args),
+      smartFunctionId: (...args) => toCdl.smartFunctionId(...args),
+      delimitedId: (...args) => toCdl.delimitedId(...args),
     }),
     sql: Object.assign((...args) => snapi.sql(...args), {
       migration: (...args) => snapi.sql.migration(...args),
@@ -147,7 +157,10 @@ module.exports = {
   // INTERNAL functions for the cds-lsp package and friends - before you use
   // it, you MUST talk with us - there can be potential incompatibilities with
   // new releases (even having the same major version):
-  $lsp: { parse: (...args) => compiler.parseX(...args), compile: (...args) => compiler.compileX(...args), getArtifactName: a => a.name },
+  $lsp: { parse: (...args) => compiler.parseX(...args),
+    compile: (...args) => compiler.compileX(...args),
+    getArtifactName: a => a.name
+  },
 
   // CSN Model related functionality
   model: {

package/lib/model/csnRefs.js

@@ -74,7 +74,7 @@
 //     const csnPath = ['definitions','P','projection','columns',0];
 //     const subElement = inspectRef( csnPath );  // type T is involved
 //     csn.definitions.T.type = 'some.other.type';
-//     // ({ inspectRef } = csnRefs( csn ));      // invalidate caches
+//     // ({ inspectRef } = csnRefs( csn ));      // drop caches
 //     … = inspectRef( csnPath );  // type T - using the cached or the new?
 //
 // On request, we might add a functions for individual cache invalidations or
@@ -155,6 +155,8 @@
 //   which contains cached data.  Such data can be a link to a CSN node (like
 //   `_effectiveType`/`elements`), scalar (like `$queryNumber`) or link to
 //   another cache object (like `$next`).
+// - A cache entry must not link to a cache object of another main definition;
+//   otherwise, individual cache invalidation does not work.
 // - Usually, each CSN object has an individual cache object.
 // - For CSN queries nodes, cache objects are _shared_: both the CSN nodes
 //   `‹query› = { SELECT: ‹select›, … }` and `‹select›` share the same cache
@@ -260,6 +262,7 @@ function csnRefs( csn, universalReady ) {
     getColumn: elem => getCache( elem, '_column' ),
     getElement: col => getCache( col, '_element' ),
     initDefinition,
+    dropDefinitionCache,
     targetAspect,
     __getCache_forEnrichCsnDebugging: obj => cache.get( obj ),
   };
@@ -334,7 +337,7 @@ function csnRefs( csn, universalReady ) {
         return art;
     }
     if (notFound !== undefined && typeof ref === 'string')
-      return notFound;          // is only meant for builtins
+      return notFound;          // is only meant for builtins and $self
     // Backend bug workaround, TODO: delete next 2 lines
     if (notFound !== undefined)
       return notFound;
@@ -396,7 +399,7 @@ function csnRefs( csn, universalReady ) {
       const location = $location &&
             (typeof $location === 'string' ? $location : locationString( $location ));
       const def = Object.keys( art ).join('+') + (location ? `:${ location }` : '');
-      throw new Error( `Inspecting non-initialized CSN node {${ def }}` );
+      throw new CompilerAssertion( `Inspecting non-initialized CSN node {${ def }}` );
     }
     const step = getCache( art, '$origin$step' );
     if (!step)
@@ -436,7 +439,7 @@ function csnRefs( csn, universalReady ) {
       return effectiveType( art ).items;
     if (step.target)
       return targetAspect( effectiveType( art ) );
-    throw Error( `Illegal navigation step ${ Object.keys(step)[0] }` );
+    throw new CompilerAssertion( `Illegal navigation step ${ Object.keys(step)[0] }` );
   }
 
   function effectiveArtFor( art, property ) {
@@ -486,6 +489,31 @@ function csnRefs( csn, universalReady ) {
       setCache( art, '$origin$step', (kind === 'element' ? step : { [kind]: step }) );
   }
 
+  function dropDefinitionCache( main ) {
+    const queries = getCache( main, '$queries' );
+    if (!queries)               // not yet initialized
+      return;
+    if (!cache.delete( main ))  // not yet initialized
+      return;
+    for (const qcache of queries || []) {
+      const { _select } = qcache;
+      for (const n of Object.keys( _select.mixin || {} ))
+        cache.delete( _select.mixin[n] );
+      dropColumnsCache( _select.columns );
+      traverseDef( _select, null, null, null, a => cache.delete( a ) ); // elements
+    }
+    traverseDef( main, null, null, null, a => cache.delete( a ) );
+  }
+
+  function dropColumnsCache( select ) {
+    if (!select)
+      return;
+    for (const col of select.columns || select.expand || select.inline || []) {
+      dropColumnsCache( col );
+      cache.delete( select );
+    }
+  }
+
   /**
    * @param {CSN.Path} csnPath
    *