@sap/cds-compiler 3.3.2 → 3.4.2

package/CHANGELOG.md

@@ -7,6 +7,39 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 3.4.2 - 2022-11-11
+
+### Fixed
+
+- Don't propagate `@cds.external` (The CDS Importer adds `@cds.external` for all
+  imported definitions beginning with cds-dk@6.3.0, see CAP release log).
+- for.odata: Ignore all `@cds.external` definitions.
+- to.sql: For sql dialect `h2`, don't turn a Decimal with length 0 into a Decfloat.
+- Extending a projection with an aspect could result in incorrect auto-redirection.
+- Annotations of aspects were not properly propagated to projections under some order-specific circumstances.
+
+## Version 3.4.0 - 2022-10-26
+
+### Added
+
+- to.sql: Add support for sql dialect `h2`, which renders SQL for H2 2.x.
+- Projections can now be extended by annotation-only aspects, e.g. `extend P with MyAspect;`.
+
+### Fixed
+
+- Properly report an error for bare `$self` references,
+  except in the `on` condition of unmanaged associations.
+- Do not dump with references to CDS variables like `$now` in `expand`/`inline`.
+- Properly report an error when trying to `cast` a column to an association.
+- to.cdl: Identifiers that are always keywords in special functions are now escaped.
+- to.edm(x):
+  + Nested annotation was not applied if outer annotation has value zero.
+  + Fix `AppliesTo=ComplexType, TypeDefinition` term definition directive.
+- to.sql/hdi/hdbcds:
+  + Properly report an error for `exists` with `$self.managed-association`
+  + For sql dialect `hana`, add an implicit alias when using `:param` in the select list
+  + Handle `$self` and magic variables during expansion of nested projections
+
 ## Version 3.3.2 - 2022-09-30
 
 ### Fixed

package/bin/cdsc.js

@@ -153,7 +153,9 @@ function cdsc_main() {
     cmdLine.args.files = [ cmdLine.args.file ];
   }
   else if (cmdLine.command === 'parseOnly') {
+    // Remap command and command-specific options.
     cmdLine.command = 'toCsn';
+    cmdLine.options.toCsn = cmdLine.options.parseOnly;
     cmdLine.options.parseOnly = true;
     cmdLine.args.files = [ cmdLine.args.file ];
   }
@@ -521,7 +523,7 @@ function executeCommandLine(command, options, args) {
         log(); // newline
       });
       if (options.showMessageId && hasAtLeastOneExplanation)
-        log(`${colorTerm.help('help')}: Messages marked with '…' have an explanation text. Use \`cdsc explain <message-id>\` for a more detailed error description.`);
+        log(`${colorTerm.asHelp('help')}: Messages marked with '…' have an explanation text. Use \`cdsc explain <message-id>\` for a more detailed error description.`);
     }
     return model;
   }

package/doc/CHANGELOG_BETA.md

@@ -8,6 +8,23 @@ Note: `beta` fixes, changes and features are listed in this ChangeLog just for i
 The compiler behavior concerning `beta` features can change at any time without notice.
 **Don't use `beta` fixes, changes and features in productive mode.**
 
+## Version 3.4.0 - 2022-MM-DD
+
+### Added `aspectWithoutElements`
+
+- Aspects can now be defined without elements, e.g. `aspect A;`. This allows the definition of annotation-only aspects.
+ Views can be extended by such an aspect. For example:
+  ```cds
+  entity V as projection on SomeEntity;
+  @anno aspect A;
+  extend V with A;
+  ```
+
+### Added `sqlMigration`
+
+- to.sql.migration: Offer something similar to to.hdi.migration, but for general SQL. Don't offer a complete out-of-the-box schema evolution, instead only
+allow lossless, easy to revert actions like adding a column or extending a string length.
+
 ## Version 3.3.0 - 2022-09-29
 
 ### Removed `nestedProjections`

package/lib/api/main.js

@@ -12,6 +12,7 @@ const forOdataNew = lazyload('../transform/forOdataNew.js');
 const toSql = lazyload('../render/toSql');
 const toCdl = require('../render/toCdl');
 const modelCompare = lazyload('../modelCompare/compare');
+const diffFilter = lazyload('../modelCompare/filter');
 const sortViews = lazyload('../model/sortViews');
 const csnUtils = lazyload('../model/csnUtils');
 const timetrace = lazyload('../utils/timetrace');
@@ -33,7 +34,7 @@ const { cloneCsnNonDict } = require('../model/csnUtils');
 const { toHdbcdsSource } = require('../render/toHdbcds');
 const { ModelError } = require('../base/error');
 const { forEach, forEachKey } = require('../utils/objectUtils');
-const { checkRemovedDeprecatedFlags } = require('../base/model');
+const { checkRemovedDeprecatedFlags, isBetaEnabled } = require('../base/model');
 const { csn2edm, csn2edmAll } = require('../edm/csn2edm');
 
 const relevantGeneralOptions = [ /* for future generic options */ ];
@@ -92,13 +93,17 @@ function checkPreTransformedCsn(csn, options, relevantOptionNames, warnAboutMism
   const { error, warning, throwWithAnyError } = messages.makeMessageFunction(csn, options, module);
 
   for (const name of relevantOptionNames ) {
-    if (options[name] !== csn.meta.options[name])
-      error('wrong-pretransformed-csn', null, {}, `Expected pre-processed CSN to have option "${ name }" set to "${ options[name] }". Found: "${ csn.meta.options[name] }"`);
+    if (options[name] !== csn.meta.options[name]) {
+      error('wrong-pretransformed-csn', null, { prop: name, value: options[name], othervalue: csn.meta.options[name] },
+            'Expected pre-processed CSN to have option $(PROP) set to $(VALUE). Found: $(OTHERVALUE)');
+    }
   }
 
   for (const name of warnAboutMismatch ) {
-    if (options[name] !== csn.meta.options[name])
-      warning('options-mismatch-pretransformed-csn', null, {}, `Expected pre-processed CSN to have option "${ name }" set to "${ options[name] }". Found: "${ csn.meta.options[name] }"`);
+    if (options[name] !== csn.meta.options[name]) {
+      warning('options-mismatch-pretransformed-csn', null, { prop: name, value: options[name], othervalue: csn.meta.options[name] },
+              'Expected pre-processed CSN to have option $(PROP) set to $(VALUE). Found: $(OTHERVALUE)');
+    }
   }
 
   throwWithAnyError();
@@ -361,6 +366,119 @@ function remapName(key, csn, filter = () => true) {
   return key;
 }
 
+/**
+ * Return all changes in artifacts between two given models.
+ * Note: Only supports changes in artifacts compiled/rendered as db-CSN/SQL.
+ *
+ * @param {CSN.Model}  csn          A clean input CSN representing the desired "after-image"
+ * @param {HdiOptions} options      Options
+ * @param {CSN.Model}  beforeImage  A db-transformed CSN representing the "before-image", or null in case no such image
+ *                                  is known, i.e. for the very first migration step
+ * @returns {object}                An object with three properties:
+ *                                  - afterImage: A db-transformed CSN representing the "after-image"
+ *                                  - drops: An array of SQL statements to drop views/tables
+ *                                  - createsAndAlters: An array of SQL statements to ALTER/CREATE tables/views
+ */
+function sqlMigration(csn, options, beforeImage) {
+  const internalOptions = prepareOptions.to.sql(options);
+  const { error, throwWithError } = messages.makeMessageFunction(csn, options, 'to.sql.migration');
+
+  if (!isBetaEnabled(internalOptions, 'sqlMigration'))
+    throw new Error('Function `to.sql.migration` requires beta-flag `sqlMigration`');
+
+  // Prepare after-image.
+  const afterImage = forSql(csn, options);
+  // Compare both images.
+  const diff = modelCompare.compareModels(beforeImage || afterImage, afterImage, internalOptions);
+  const diffFilterObj = diffFilter[options.sqlDialect];
+
+  if (diffFilterObj) {
+    diff.extensions.forEach(ex => diffFilterObj.extension(ex, error));
+    diff.migrations.forEach(migration => diffFilterObj.migration(migration, error));
+    Object.entries(diff.deletions).forEach(entry => diffFilterObj.deletion(entry, error));
+  }
+
+  const drops = {
+    creates: {},
+    final: Object.entries(diff.deletions).reduce((previous, [ name, artifact ]) => {
+      previous[name] = `DROP ${ (artifact.query || artifact.projection) ? 'VIEW' : 'TABLE' } ${ artifact['@cds.persistence.name'] };`;
+      return previous;
+    }, {}),
+  };
+
+  const cleanup = [];
+  // Delete artifacts that are already present in csn
+  if (beforeImage?.definitions) {
+    Object.keys(beforeImage.definitions).forEach((artifactName) => {
+      const beforeArtifact = beforeImage.definitions[artifactName];
+      const diffArtifact = diff.definitions[artifactName];
+      // TODO: exists, abstract? isPersistedOnDb?
+      if (diffArtifact && diffArtifact['@cds.persistence.name'] && !diffArtifact['@cds.persistence.skip'] &&
+        (diffArtifact.query || diffArtifact.projection) &&
+        (diffArtifact[modelCompare.isChanged] === true || // we know it changed because we compared two views
+          diffArtifact[modelCompare.isChanged] === undefined)) { // if it was removed in the after, then we don't have the flag
+        drops.creates[artifactName] = `DROP VIEW ${ diffArtifact['@cds.persistence.name'] };`;
+      } // TODO: What happens with a changed kind -> entity becomes a view?
+      else if (diffArtifact &&
+        diffArtifact['@cds.persistence.skip'] !== true &&
+        diffArtifact.kind === beforeArtifact.kind && // detect action -> entity
+        csnUtils.isPersistedAsView(diffArtifact) === csnUtils.isPersistedAsView(beforeArtifact) // detect view -> entity
+      ) { // don't render again, but need info for primary key extension
+        diffArtifact['@cds.persistence.skip'] = true;
+        cleanup.push(() => delete diffArtifact['@cds.persistence.skip']);
+      }
+    });
+  }
+
+  // Convert the diff to SQL.
+  if (!internalOptions.beta)
+    internalOptions.beta = {};
+
+  internalOptions.beta.sqlExtensions = true;
+
+  // eslint-disable-next-line no-unused-vars
+  const { deletions, migrations, ...hdbkinds } = toSql.toSqlDdl(diff, internalOptions);
+
+  cleanup.forEach(fn => fn());
+  // TODO: Handle `ADD CONSTRAINT` etc!
+  const sortOrder = sortViews({ sql: {}, csn: afterImage });
+
+  const dropSqls = [];
+  const createAndAlterSqls = [];
+  // Turn the structured result into just a flat dictionary of "artifact name": "sql"
+  const flatSqlDict = Object.values(hdbkinds).reduce((prev, curr) => {
+    forEach(curr, (name, value) => {
+      prev[name] = value;
+    });
+    return prev;
+  }, Object.create(null));
+
+  // Sort all the SQL statements according to the overall order
+  for (const { name } of sortOrder) {
+    if (drops.final[name])
+      dropSqls.push(drops.final[name]);
+    else if (drops.creates[name])
+      dropSqls.push(drops.creates[name]);
+
+    // No else-if, since we have drop-creates for views!
+    if (flatSqlDict[name])
+      createAndAlterSqls.push(flatSqlDict[name]);
+    else if (migrations[name])
+      createAndAlterSqls.push(...migrations[name].map(m => m.sql));
+  }
+
+  // We need to drop the things without dependants first - so inversely sorted
+  dropSqls.reverse();
+
+  throwWithError();
+
+  return {
+    afterImage,
+    drops: dropSqls,
+    createsAndAlters: createAndAlterSqls,
+  };
+}
+
 /**
  * Return all changes in artifacts between two given models.
  * Note: Only supports changes in entities (not views etc.) compiled/rendered as HANA-CSN/SQL.
@@ -369,17 +487,7 @@ function remapName(key, csn, filter = () => true) {
  * @param {HdiOptions} options      Options
  * @param {CSN.Model}  beforeImage  A HANA-transformed CSN representing the "before-image", or null in case no such image
  *                                  is known, i.e. for the very first migration step
- * @returns {object} - afterImage:  The desired after-image in HANA-CSN format
- *                   - definitions: An array of objects with all artifacts in the after-image. Each object specifies
- *                                  the artifact filename, the suffix, and the corresponding SQL statement to create
- *                                  the artifact.
- *                   - deletions:   An array of objects with the deleted artifacts. Each object specifies the artifact
- *                                  filename and the suffix.
- *                   - migrations:  An array of objects with the changed (migrated) artifacts. Each object specifies the
- *                                  artifact filename, the suffix, and the changeset (an array of changes, each specifying
- *                                  whether it incurs potential data loss, and its respective SQL statement(s), with
- *                                  multiple statements concatenated as a multi-line string in case the change e.g.
- *                                  consists of a column drop and add).
+ * @returns {migration} The migration result
  */
 function hdiMigration(csn, options, beforeImage) {
   const internalOptions = prepareOptions.to.hdi(options);
@@ -387,11 +495,14 @@ function hdiMigration(csn, options, beforeImage) {
   // Prepare after-image.
   const afterImage = forHdi(csn, options);
 
-  // Compare both images.
   const diff = modelCompare.compareModels(beforeImage || afterImage, afterImage, internalOptions);
 
   // Convert the diff to SQL.
-  internalOptions.forHana = true; // Make it pass the SQL rendering
+  if (!internalOptions.beta)
+    internalOptions.beta = {};
+
+  internalOptions.beta.sqlExtensions = true;
+
   const { deletions, migrations, ...hdbkinds } = toSql.toSqlDdl(diff, internalOptions);
 
   return {
@@ -449,6 +560,8 @@ function createSqlMigrations(migrations, afterImage) {
 
 hdi.migration = hdiMigration;
 
+sql.migration = sqlMigration;
+
 /**
  * Process the given CSN into HDBCDS artifacts.
  *
@@ -922,3 +1035,19 @@ function lazyload(moduleName) {
  *
  * @typedef {object} edms
  */
+
+/**
+ * - afterImage:  The desired after-image in db-CSN format
+ * - definitions: An array of objects with all artifacts in the after-image. Each object specifies
+ *                the artifact filename, the suffix, and the corresponding SQL statement to create
+ *                the artifact.
+ * - deletions:   An array of objects with the deleted artifacts. Each object specifies the artifact
+ *                filename and the suffix.
+ * - migrations:  An array of objects with the changed (migrated) artifacts. Each object specifies the
+ *                artifact filename, the suffix, and the changeset (an array of changes, each specifying
+ *                whether it incurs potential data loss, and its respective SQL statement(s), with
+ *                multiple statements concatenated as a multi-line string in case the change e.g.
+ *                consists of a column drop and add).
+ *
+ * @typedef {object} migration
+ */

package/lib/api/validate.js

@@ -78,7 +78,7 @@ const validators = {
     expected: () => 'type array',
     found: val => `type ${ typeof val }`,
   },
-  sqlDialect: generateStringValidator([ 'sqlite', 'hana', 'plain', 'postgres' ]),
+  sqlDialect: generateStringValidator([ 'sqlite', 'hana', 'plain', 'postgres', 'h2' ]),
   sqlMapping: generateStringValidator([ 'plain', 'quoted', 'hdbcds' ]),
   odataVersion: generateStringValidator([ 'v2', 'v4' ]),
   odataFormat: generateStringValidator([ 'flat', 'structured' ]),
@@ -161,8 +161,13 @@ function validate(options, moduleName, customValidators = {}, combinationValidat
     forEach(options, (optionName, optionValue) => {
       const validator = customValidators[optionName] || validators[optionName] || booleanValidator;
 
-      if (!validator.validate(optionValue))
-        error('invalid-option', null, {}, `Expected option "${ optionName }" to have "${ validator.expected(optionValue) }". Found: "${ validator.found(optionValue) }"`);
+      if (!validator.validate(optionValue)) {
+        error('invalid-option', null, {
+          prop: optionName,
+          value: validator.expected(optionValue),
+          othervalue: validator.found(optionValue),
+        }, 'Expected option $(PROP) to have $(VALUE). Found: $(OTHERVALUE)');
+      }
     });
     throwWithAnyError();
   }

package/lib/base/dictionaries.js

@@ -19,7 +19,7 @@ function dictAdd( dict, name, entry, duplicateCallback ) {
       duplicateCallback( name, found.name.location, found );
   }
   found.$duplicates.push( entry );
-  if (Array.isArray(entry.$duplicates))
+  if (Array.isArray( entry.$duplicates ))
     found.$duplicates.push( ...entry.$duplicates )
   else if (duplicateCallback && name) // do not complain with empty name ''
     duplicateCallback( name, entry.name.location, entry );
@@ -31,7 +31,7 @@ function dictForEach( dict, callback ) {
   // TODO: probably define an extra dictForEachArray()
   for (const name in dict) {
     const entry = dict[name];
-    if (Array.isArray(entry)) {
+    if (Array.isArray( entry )) {
       entry.forEach( callback );
     }
     else {
@@ -53,8 +53,8 @@ function dictAddArray( dict, name, entry, messageCallback ) {
     dict[name] = entry;         // also ok if array (redefined)
     return entry;
   }
-  if (Array.isArray(entry)) {
-    if (Array.isArray(found)) {
+  if (Array.isArray( entry )) {
+    if (Array.isArray( found )) {
       dict[name] = [ ...found, ...entry ];
     }
     else {
@@ -65,7 +65,7 @@ function dictAddArray( dict, name, entry, messageCallback ) {
     }
   }
   else {
-    if (Array.isArray(found)) {
+    if (Array.isArray( found )) {
       dict[name] = [ ...found, entry ];
     }
     else {
@@ -84,7 +84,7 @@ function dictAddArray( dict, name, entry, messageCallback ) {
 // Push `entry` to the array value with key `name` in the dictionary `dict`.
 function pushToDict( dict, name, entry ) {
   if (dict[name])
-    dict[name].push(entry);
+    dict[name].push( entry );
   else
     dict[name] = [entry];
 }

package/lib/base/keywords.js

@@ -842,5 +842,109 @@ module.exports = {
     'WHERE',
     'WINDOW',
     'WITH'
+  ],
+  // H2 keywords, used for smart quoting in to-sql.plain.postgres
+  // Taken from http://www.h2database.com/html/advanced.html#keywords
+  h2: [
+    'ALL',
+    'AND',
+    'ANY',
+    'ARRAY',
+    'AS',
+    'ASYMMETRIC',
+    'AUTHORIZATION',
+    'BETWEEN',
+    'BOTH',
+    'CASE',
+    'CAST',
+    'CHECK',
+    'CONSTRAINT',
+    'CROSS',
+    'CURRENT_CATALOG',
+    'CURRENT_DATE',
+    'CURRENT_PATH',
+    'CURRENT_ROLE',
+    'CURRENT_SCHEMA',
+    'CURRENT_TIME',
+    'CURRENT_TIMESTAMP',
+    'CURRENT_USER',
+    'DAY',
+    'DEFAULT',
+    'DISTINCT',
+    'ELSE',
+    'END',
+    'EXCEPT',
+    'EXISTS',
+    'FALSE',
+    'FETCH',
+    'FOR',
+    'FOREIGN',
+    'FROM',
+    'FULL',
+    'GROUP',
+    'GROUPS',
+    'HAVING',
+    'HOUR',
+    'IF',
+    'ILIKE',
+    'IN',
+    'INNER',
+    'INTERSECT',
+    'INTERVAL',
+    'IS',
+    'JOIN',
+    'KEY',
+    'LEADING',
+    'LEFT',
+    'LIKE',
+    'LIMIT',
+    'LOCALTIME',
+    'LOCALTIMESTAMP',
+    'MINUS',
+    'MINUTE',
+    'MONTH',
+    'NATURAL',
+    'NOT',
+    'NULL',
+    'OFFSET',
+    'ON',
+    'OR',
+    'ORDER',
+    'OVER',
+    'PARTITION',
+    'PRIMARY',
+    'QUALIFY',
+    'RANGE',
+    'REGEXP',
+    'RIGHT',
+    'ROW',
+    'ROWNUM',
+    'ROWS',
+    'SECOND',
+    'SELECT',
+    'SESSION_USER',
+    'SET',
+    'SOME',
+    'SYMMETRIC',
+    'SYSTEM_USER',
+    'TABLE',
+    'TO',
+    'TOP',
+    'TRAILING',
+    'TRUE',
+    'UESCAPE',
+    'UNION',
+    'UNIQUE',
+    'UNKNOWN',
+    'USER',
+    'USING',
+    'VALUE',
+    'VALUES',
+    'WHEN',
+    'WHERE',
+    'WINDOW',
+    'WITH',
+    'YEAR',
+    '_ROWID_'
   ]
 }