@sap/cds-compiler 5.4.4 → 5.5.2

package/lib/gen/Dictionary.json

@@ -1089,8 +1089,7 @@
       "Type": "Core.Tag",
       "AppliesTo": [
         "EntityContainer"
-      ],
-      "$experimental": true
+      ]
     },
     "Common.mediaUploadLink": {
       "Type": "Edm.String",
@@ -4475,6 +4474,7 @@
       "$kind": "ComplexType",
       "BaseType": "UI.DataFieldAbstract",
       "Properties": {
+        "ID": "Edm.String",
         "Actions": "Collection(UI.DataFieldForActionAbstract)",
         "Label": "Edm.String",
         "Criticality": "UI.CriticalityType",

package/lib/language/antlrParser.js

@@ -17,11 +17,6 @@ const { XsnSource } = require('../compiler/xsn-model');
 const Parser = require('../gen/languageParser').default;
 const Lexer = require('../gen/languageLexer').default;
 
-const CdlLexer = require( '../parsers/Lexer' );
-const CdlParser = require( '../gen/CdlParser' );
-const { createMessageFunctions } = require( '../base/messages' );
-const { CompilerAssertion } = require( '../base/error' );
-
 // Error listener used for ANTLR4-generated parser
 class ErrorListener extends antlr4.error.ErrorListener {
   // method which is called by generated parser with --trace-parser[-amg]:
@@ -125,18 +120,7 @@ function tokenTypeOf( recognizer, literalName ) {
 // the AST locations and error messages.  If provided, `options` are compile
 // options.
 
-const rules = {
-  cdl: { func: 'start', returns: 'source', $frontend: 'cdl' },
-  query: { func: 'queryEOF', returns: 'query' },
-  expr: { func: 'conditionEOF', returns: 'cond' }, // yes, condition
-};
-
-function parse( source, filename = '<undefined>.cds',
-                options = {}, messageFunctions = null,
-                rule = 'cdl' ) {
-  if (options.newParser)
-    return parseWithNewParser( source, filename, options, messageFunctions, rule );
-
+function parse( source, filename, options, messageFunctions, rulespec ) {
   const lexer = new Lexer( new antlr4.InputStream(source) );
   const tokenStream = new RewriteTypeTokenStream(lexer);
   /** @type {object} */
@@ -179,10 +163,9 @@ function parse( source, filename = '<undefined>.cds',
     parser.addParseListener(options.parseListener);
 
 
-  const rulespec = rules[rule];
   let tree;
   try {
-    tree = rule && parser[rulespec.func]();
+    tree = parser[rulespec.func]();
   }
   catch (e) {
     if (e instanceof RangeError && e.message.match(/Maximum.*exceeded$/i)) {
@@ -219,96 +202,4 @@ function parse( source, filename = '<undefined>.cds',
   return ast;
 }
 
-function parseWithNewParser( source, filename, options, messageFunctions, rule ) {
-  if (CdlParser.tracingParser)  // tracing → direct console output of message
-    messageFunctions = createMessageFunctions( {}, 'parse', {} );
-  const lexer = new CdlLexer( filename, source );
-  const parser = new CdlParser( lexer, options, messageFunctions ).init();
-  parser.filename = filename;   // LSP compatibility
-
-  const { parseListener, attachTokens } = options;
-  if (parseListener || attachTokens) {
-    const combined = [];
-    const { tokens, comments, docComments } = parser;
-    const length = tokens.length + comments.length + docComments.length;
-    let tokenIdx = 0;
-    let commentIdx = 0;
-    let docCommentIdx = 0;
-    for (let index = 0; index < length; ++index) {
-      if (tokens[tokenIdx].location.tokenIndex === index) // EOF has largest tokenIndex
-        combined.push( tokens[tokenIdx++] );
-      else if (comments[commentIdx]?.location.tokenIndex === index)
-        combined.push( comments[commentIdx++] );
-      else
-        combined.push( docComments[docCommentIdx++] );
-    }
-    if (!combined.at( -1 ))
-      throw new CompilerAssertion( 'Invalid values for `tokenIndex`' );
-    for (const tok of combined)
-      tok.start = lexer.characterPos( tok.location.line, tok.location.col );
-
-    parser._input = { tokens: combined, lexer }; // lexer for characterPos() in cdshi.js
-    parser.getTokenStream = function getTokenStream() {
-      return this._input;
-    };
-  }
-  // LSP feature: provide parse listener with ANTLR-like context:
-  if (parseListener) {
-    // TODO LSP: we could also call different listener methods: then LSP could
-    // have dedicated methods for ANTLR-based and new parser
-    parser.rule_ = function rule_( ...args ) {
-      CdlParser.prototype.rule_.apply( this, args );
-      let state = this.s;
-      while (typeof this.table[--state] !== 'string')
-        ;
-      const $ctx = {    // TODO LSP: more to add?
-        parser: this,   // set in generated ANTLR parser for each rule context
-        ruleName: this.table[state], // instead of ruleIndex
-        start: this.la(),       // set in Parser#enterRule
-        stop: null,
-      };
-      parser.stack.at( -1 ).$ctx = $ctx;
-      parseListener.enterEveryRule( $ctx );
-    };
-    parser.exit_ = function exit_( ...args ) {
-      const { $ctx } = parser.stack.at( -1 );
-      // TODO: what should we do in case of errors?
-      $ctx.stop = this.lb();
-      parseListener.exitEveryRule( $ctx );
-      return CdlParser.prototype.exit_.apply( this, args );
-    };
-    parser.c = function c( ...args ) { // consume
-      const symbol = this.la();
-      const result = CdlParser.prototype.c.apply( this, args );
-      if (result)
-        parseListener.visitTerminal( { symbol } );
-      return result;
-    };
-    parser.skipToken_ = function skipToken_( ...args ) { // skip token in error recovery
-      const symbol = this.la();
-      CdlParser.prototype.skipToken_.apply( this, args ); // = `++this.tokenIdx`
-      parseListener.visitErrorNode( { symbol } );
-    };
-  }
-  const result = {};
-  const rulespec = rules[rule];
-  if (rulespec) {
-    try {
-      parser[rulespec.func]( result );
-    }
-    catch (e) {
-      if (!(e instanceof RangeError && /Maximum.*exceeded$/i.test( e.message )))
-        throw e;
-      messageFunctions.error('syntax-invalid-source', { file: filename },
-                             { '#': 'cdl-stackoverflow' } );
-      result[rulespec.returns] = undefined;
-    }
-  }
-  const ast = result[rulespec?.returns] || (rule === 'cdl' ? new XsnSource( 'cdl' ) : {} );
-  ast.options = options;
-  if (attachTokens === true || attachTokens === filename)
-    ast.tokenStream = parser._input;
-  return ast;
-}
-
 module.exports = parse;

package/lib/main.js

@@ -1,19 +1,23 @@
-// Main entry point for the CDS Compiler
+// Main entry point for the CDS Compiler (API)
 //
-// File for external usage = which is read in other modules with
-//   require('cdsv');
+// Other NPM modules must not require any other files than this one.
 
 // Proposed intra-module lib dependencies:
 //  - lib/base/<file>.js: can be required by all others, requires no other
-//    of this project
+//    of this project, except a lib/base/<other-file>.js
+//  - lib/util/<file>.js: TODO - clarify diff to lib/base/
 //  - lib/<dir>/<file>.js: can be required by other files lib/<dir>/,
-//    can require other files lib/<dir>/ and lib/base/<file>.js
+//    can require other files in lib/<dir>/ and lib/base/<file>.js,
+//    and lib/<other-dir>/ (the index.js in <other-dir>).
 //  - lib/main.js (this file): can be required by none in lib/ (only in
 //    bin/ and test/), can require any other
 
 'use strict';
 
+const lazyload = require('./base/lazyload')( module );
+
 const { traceApi } = require('./api/trace');
+
 const snapi = lazyload('./api/main');
 const csnUtils = lazyload('./model/csnUtils');
 const model_api = lazyload('./model/api');
@@ -22,7 +26,7 @@ const sqlIdentifier = lazyload('./sql-identifier');
 const keywords = lazyload( './base/keywords' );
 const toCdl = lazyload('./render/toCdl');
 
-const parseLanguage = lazyload('./language/antlrParser');
+const parsers = lazyload('./parsers');
 const compiler = lazyload('./compiler');
 const shared = lazyload('./compiler/shared');
 const define = lazyload('./compiler/define');
@@ -43,8 +47,8 @@ function parseCdl( cdlSource, filename, options = {} ) {
   const messageFunctions = messages.createMessageFunctions( options, 'parse', model );
   model.$messageFunctions = messageFunctions;
 
-  const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
-                             messageFunctions );
+  const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
+                                messageFunctions );
   sources[filename] = xsn;
   shared.fns( model );
   define( model );
@@ -55,16 +59,16 @@ function parseCdl( cdlSource, filename, options = {} ) {
 
 function parseCql( cdlSource, filename = '<query>.cds', options = {} ) {
   const messageFunctions = messages.createMessageFunctions( options, 'parse' );
-  const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
-                             messageFunctions, 'query' );
+  const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
+                                messageFunctions, 'query' );
   messageFunctions.throwWithError();
   return toCsn.compactQuery( xsn );
 }
 
 function parseExpr( cdlSource, filename = '<expr>.cds', options = {} ) {
   const messageFunctions = messages.createMessageFunctions( options, 'parse' );
-  const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
-                             messageFunctions, 'expr' );
+  const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
+                                messageFunctions, 'expr' );
   messageFunctions.throwWithError();
   return toCsn.compactExpr( xsn );
 }
@@ -191,28 +195,3 @@ module.exports = {
     isInReservedNamespace: (...args) => builtins.isInReservedNamespace(...args),
   },
 };
-
-/**
- * Load the module on-demand and not immediately.
- *
- * @param {string} moduleName Name of the module to load - like with require
- * @returns {object} A Proxy that handles the on-demand loading
- */
-function lazyload(moduleName) {
-  let module;
-  return new Proxy(((...args) => {
-    if (!module)
-      module = require(moduleName);
-
-    if (module.apply && typeof module.apply === 'function')
-      return module.apply(this, args);
-    return module; // for destructured calls
-  }), {
-    get(target, name) {
-      if (!module)
-        module = require(moduleName);
-
-      return module[name];
-    },
-  });
-}

package/lib/model/cloneCsn.js

@@ -2,7 +2,7 @@
 
 const { csnPropertyOrder } = require('../json/to-csn');
 const { ModelError } = require('../base/error');
-const { setHidden } = require('../utils/objectUtils');
+const { setHidden, hasNonEnumerable } = require('../utils/objectUtils');
 const { isAnnotationExpression } = require('../base/builtins');
 
 const csnDictionaries = {
@@ -110,10 +110,6 @@ function cloneCsn( csn, options, sort ) {
   return r;
 }
 
-function hasNonEnumerable( object, property ) {
-  return Object.prototype.hasOwnProperty.call( object, property ) &&
-    !Object.prototype.propertyIsEnumerable.call( object, property );
-}
 
 /**
  * Deeply clone the given CSN dictionary and return it.

package/lib/modelCompare/utils/filter.js

@@ -61,6 +61,7 @@ module.exports = {
 function getFilterObject( options, dialect, extensionCallback, migrationCallback, removeConstraintsCallback, primaryKeyCallback ) {
   const context = { hasLossyChanges: false };
   const raiseErrorOrMarkAsLossy = getSafeguardManager(context, options);
+  const messageVariant = options.script ? 'script' : 'std';
   return {
     // will be called with a simple Array.filter, as we need to filter constraint `ADD` for SQLite
     extension: ({
@@ -69,7 +70,7 @@ function getFilterObject( options, dialect, extensionCallback, migrationCallback
       let returnValue = true;
       forEach(elements, (name, element) => {
         if (dialect !== 'sqlite' && isKey(element))
-          message('type-unsupported-key-change', [ 'definitions', extend, 'elements', name ], { id: name, '#': 'std' } );
+          message('migration-unsupported-key-change', [ 'definitions', extend, 'elements', name ], { id: name, '#': 'std' } );
         else if (extensionCallback && !extensionCallback(extend, name, element, { error, warning }))
           returnValue = false;
       });
@@ -82,23 +83,31 @@ function getFilterObject( options, dialect, extensionCallback, migrationCallback
     // will be called with a Array.forEach
     migration: (migrations, { error, warning, message }) => {
       forEach(migrations.remove, (name, migration) => {
-        raiseErrorOrMarkAsLossy(migration, () => error('def-unsupported-element-drop', [ 'definitions', migrations.migrate, 'elements', name ], {}, 'Dropping elements is not supported'));
+        raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-element-drop', id => message(id, [ 'definitions', migrations.migrate, 'elements', name ], { '#': messageVariant }));
       });
 
       forEach(migrations.change, (name, migration) => {
         const loc = [ 'definitions', migrations.migrate, 'elements', name ];
-        if (migration.new.type === migration.old.type && migration.new.length < migration.old.length)
-          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-length-change', loc, { id: name }, 'Changed element $(ID) is a length reduction and is not supported'));
-        else if (migration.new.type === migration.old.type && migration.new.scale !== migration.old.scale)
-          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-scale-change', loc, { id: name }, 'Changed element $(ID) is a scale change and is not supported'));
-        else if (migration.new.type === migration.old.type && migration.new.precision !== migration.old.scale)
-          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-precision-change', loc, { id: name }, 'Changed element $(ID) is a precision change and is not supported'));
-        else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type))
-          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-change', loc, { id: name, name: migration.old.type, type: migration.new.type }, 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported'));
-        else if (dialect !== 'sqlite' && isKey(migration.new) && !isKey(migration.old)) // key added/changed - pg, hana and sqlite do not support it, h2 probably also - issues when data is in the table already
-          raiseErrorOrMarkAsLossy(migration, () => message('type-unsupported-key-change', [ 'definitions', migrations.migrate, 'elements', name ], { id: name, '#': 'changed' } ));
-        else if (migrationCallback)
+        if (migration.new.type === migration.old.type && migration.new.length < migration.old.length) {
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-length-change', id => message(id, loc, { '#': messageVariant, id: name }));
+        }
+        else if (migration.new.type === migration.old.type && migration.new.scale !== migration.old.scale) {
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-scale-change', id => message(id, loc, { '#': messageVariant, id: name }));
+        }
+        else if (migration.new.type === migration.old.type && migration.new.precision !== migration.old.scale) {
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-precision-change', id => message(id, loc, { '#': messageVariant, id: name }));
+        }
+        else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type)) {
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-change', id => message(id, loc, {
+            '#': messageVariant, id: name, name: migration.old.type, type: migration.new.type,
+          }));
+        }
+        else if (dialect !== 'sqlite' && isKey(migration.new) && !isKey(migration.old)) { // key added/changed - pg, hana and sqlite do not support it, h2 probably also - issues when data is in the table already
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-key-change', id => message( id, [ 'definitions', migrations.migrate, 'elements', name ], { id: name, '#': 'changed' } ));
+        }
+        else if (migrationCallback) {
           migrationCallback(migrations.migrate, name, migration, migrations.change, error);
+        }
 
         if (options.script && migration.lossy && migrationCallback)
           migrationCallback(migrations.migrate, name, migration, migrations.change, error);
@@ -115,9 +124,9 @@ function getFilterObject( options, dialect, extensionCallback, migrationCallback
         });
       }
     },
-    deletion: ([ artifactName, artifact ], error) => {
+    deletion: ([ artifactName, artifact ], { message }) => {
       if (isPersistedAsTable(artifact))
-        raiseErrorOrMarkAsLossy(artifact, () => error('def-unsupported-table-drop', [ 'definitions', artifactName ], 'Dropping tables is not supported'));
+        raiseErrorOrMarkAsLossy(artifactName, artifact, 'migration-unsupported-table-drop', id => message(id, [ 'definitions', artifactName ], { '#': messageVariant }));
     },
     changedPrimaryKeys: (changedPrimaryKeyArtifactName) => {
       if (primaryKeyCallback)
@@ -191,13 +200,30 @@ function filterCsn( csn ) {
 }
 
 function getSafeguardManager( context, options ) {
-  return function raiseErrorOrMarkAsLossy(migration, raiseError) {
-    if (!options.script) {
-      raiseError();
-    }
-    else {
-      migration.lossy = true;
+  return function raiseErrorOrMarkAsLossy(name, migration, id, raiseMessage) {
+    raiseMessage(id);
+
+    if (options.script) {
+      migration.details = getDetails(id, name);
+      migration.lossy = id !== 'migration-unsupported-key-change';
       context.hasLossyChanges = true;
     }
   };
 }
+
+const details = {
+  'migration-unsupported-element-drop': 'drop of element',
+  'migration-unsupported-length-change': 'length reduction of element',
+  'migration-unsupported-scale-change': 'scale reduction of element',
+  'migration-unsupported-precision-change': 'precision reduction of element',
+  'migration-unsupported-change': 'incompatible type change of element',
+  'migration-unsupported-key-change': 'key property change of element',
+  'migration-unsupported-table-drop': 'drop of entity',
+};
+
+function getDetails(id, name) {
+  if (details[id])
+    return `${details[id] } "${ name }" - check warnings for details`;
+
+  return null;
+}