@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/modelCompare/compare.js

@@ -4,9 +4,12 @@ const { makeMessageFunction } = require('../base/messages');
 const {
   forEachDefinition,
   forEachMember,
-  hasAnnotationValue
+  isPersistedAsTable,
+  isPersistedAsView
 } = require('../model/csnUtils');
 const { isBetaEnabled } = require('../base/model');
+// used to mark a view as changed so we know to drop-create it
+const isChanged = Symbol('Marks a view as changed');
 
 /**
  * Compares two models, in HANA-transformed CSN format, to each other.
@@ -14,7 +17,7 @@ const { isBetaEnabled } = require('../base/model');
  * @param beforeModel the before-model
  * @param afterModel the after-model
  * @param {HdiOptions|false} options
- * @returns {object} the sets of deletions, extensions, and migrations of entities necessary to transform the before-model
+ * @returns {ModelDiff} the sets of deletions, extensions, and migrations of entities necessary to transform the before-model
  * to the after-model, together with all the definitions of the after-model
  */
 function compareModels(beforeModel, afterModel, options) {
@@ -46,17 +49,18 @@ function validateCsnVersions(beforeModel, afterModel, options) {
 
   if (!beforeVersionParts || beforeVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(beforeModel, options, 'modelCompare');
-    error(null, null, `Invalid CSN version: ${beforeVersion}`);
+    error(null, null, { version: beforeVersion }, 'Invalid CSN version: $(VERSION)');
     throwWithAnyError();
   }
   if (!afterVersionParts || afterVersionParts.length < 2) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    error(null, null, `Invalid CSN version: ${afterVersion}`);
+    error(null, null, { version: afterVersion }, 'Invalid CSN version: $(VERSION)');
     throwWithAnyError();
   }
   if (beforeVersionParts[0] > afterVersionParts[0] && !(options && options.allowCsnDowngrade)) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    error(null, null, `Incompatible CSN versions: ${afterVersion} is a major downgrade from ${beforeVersion}. Is @sap/cds-compiler version ${require('../../package.json').version} outdated?`);
+    error(null, null, { value: afterVersion, othervalue: beforeVersion, version: require('../../package.json').version },
+      'Incompatible CSN versions: $(VALUE) is a major downgrade from $(OTHERVALUE). Is @sap/cds-compiler version $(VERSION) outdated?');
     throwWithAnyError();
   }
 }
@@ -65,7 +69,7 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
   return function compareArtifacts(artifact, name) {
     function addElements() {
       const elements = {};
-      forEachMember(artifact, getElementComparator(otherArtifact, elements));
+      forEachMember(artifact, getElementComparator(otherArtifact, elements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(elements).length > 0) {
         elementAdditions.push(addedElements(name, elements));
       }
@@ -92,12 +96,12 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
         migration.properties = changedProperties;
       }
 
-      forEachMember(otherArtifact, getElementComparator(artifact, removedElements));
+      forEachMember(otherArtifact, getElementComparator(artifact, removedElements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(removedElements).length > 0) {
         migration.remove = removedElements;
       }
 
-      forEachMember(artifact, getElementComparator(otherArtifact, null, changedElements));
+      forEachMember(artifact, getElementComparator(otherArtifact, null, changedElements), [ 'definitions', name ], true, { elementsOnly: true });
       if (Object.keys(changedElements).length > 0) {
         migration.change = changedElements;
       }
@@ -116,10 +120,18 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
       // Arguments are interchanged in this case: `artifact` from beforeModel and `otherArtifact` from afterModel.
       if (isPersisted && !isPersistedOther) {
         deletedEntities[name] = artifact;
+      } else if(isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
+        deletedEntities[name] = artifact;
       }
       return;
     }
 
+    // to make it easier to know which views to drop-create
+    if(isPersistedAsView(artifact) && isPersistedAsView(otherArtifact)) {
+      // TODO: Check only on artifact.query/projection BUT: Need to manually check for sql-snippets then!
+      artifact[isChanged] = JSON.stringify(artifact) !== JSON.stringify(otherArtifact);
+    }
+
     // Looking for added entities and added/deleted/changed elements.
     // Parameters: `artifact` from afterModel and `otherArtifact` from beforeModel.
 
@@ -146,15 +158,6 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
   };
 }
 
-function isPersistedAsTable(artifact) {
-  return artifact.kind === 'entity'
-      && !artifact._ignore
-      && !artifact.abstract
-      && (!artifact.query && !artifact.projection || hasAnnotationValue(artifact, '@cds.persistence.table'))
-      && !hasAnnotationValue(artifact, '@cds.persistence.skip')
-      && !hasAnnotationValue(artifact, '@cds.persistence.exists');
-}
-
 function getElementComparator(otherArtifact, addedElementsDict = null, changedElementsDict = null) {
   return function compareElements(element, name) {
     if (element._ignore) {
@@ -244,5 +247,36 @@ function changedElement(element, otherElement) {
 
 module.exports = {
   compareModels,
-  deepEqual
+  deepEqual,
+  isChanged
 };
+
+/**
+ * A ModelDiff encapsulates the changes between two models ("before" and "after"). It contains information
+ * about changes to .elements and removed artifacts.
+ * 
+ * @typedef {object} ModelDiff
+ * @property {CSN.Definitions} definitions The artifacts present in the "after" model
+ * @property {CSN.Definitions} deletions The artifacts present in the "before", but not in the "after"
+ * @property {extension[]} extensions The elements added to artifacts
+ * @property {migration[]} migrations Altered or removed elements
+ */
+
+/**
+ * @typedef {object} extension
+ * @property {CSN.Elements} elements The elements that where added
+ * @property {string} extend Name of the artifact that the .elements need to be added to
+ */
+
+/**
+ * @typedef {object} migration
+ * @property {Object.<string, ChangeSet>} change An object of changes - the key being the name of the changed element, the value being the change.
+ * @property {string} migrate Name of the artifact that the .change and .remove apply to
+ * @property {CSN.Elements} remove An object of removed elements
+ */
+
+/**
+ * @typedef {object} ChangeSet Describes the change of one element
+ * @property {CSN.Element} old The old element definition
+ * @property {CSN.Element} new The new element definition
+ */

package/lib/modelCompare/filter.js

@@ -0,0 +1,83 @@
+// Each db has some changes that it can and cannot represent, or that cause problems only on that specific db
+// In this file, we define rules for each db-dialect to detect and act on these cases.
+
+const { forEach } = require("../utils/objectUtils");
+const { isPersistedAsTable } = require('../model/csnUtils');
+
+function isKey(element) {
+  return element.key;
+}
+
+module.exports = {
+  sqlite: getFilterObject(
+    'sqlite', 
+    (extend, name, element, error) => {
+      if(isKey(element)) { // Key must not be extended
+        error(null, ['definitions', extend, 'elements', name], {id: name, name: 'sqlite'}, "Added element $(ID) is a primary key change and will not work with $(NAME)")
+      }
+    },
+    (migrate, name, migration, change, error) => {
+      const newIsKey = isKey(migration.new);
+      const oldIsKey = isKey(migration.old);
+      if((newIsKey || oldIsKey) && oldIsKey !== newIsKey) { // Turned into key or key was removed
+        error(null, ['definitions', migrate, 'elements', name], {id: name, name: 'sqlite'}, "Changed element $(ID) is a primary key change and will not work with $(NAME)")
+      } else { // Ignore simple migrations
+        delete change[name];
+      }
+    })
+}
+
+function getFilterObject(dialect, extensionCallback, migrationCallback) {
+  return {
+        // will be called with a simple Array.forEach
+    extension: ({ elements, extend }, error) => {
+      forEach(elements, (name, element) => {
+        extensionCallback(extend, name, element, error);
+      });
+    },
+    // will be called with a Array.map, as we need to filter "change" for SQLite
+    migration: ({ change, migrate, remove }, error) => {
+      forEach(remove, (name) => {
+        error(null, ['definitions', migrate, 'elements', name], {}, "Dropping elements is not supported")
+      });
+
+      forEach(change, (name, migration) => {
+        if(migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type)) {
+          error(null, ['definitions', migrate, 'elements', name], { 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(migration.new.length < migration.old.length) {
+          error(null, ['definitions', migrate, 'elements', name], { id: name }, "Changed element $(ID) is a length reduction and is not supported")
+        } else {
+          migrationCallback(migrate, name, migration, change, error);
+        }
+
+        // TODO: precision/scale growth
+      });
+    },
+    deletion: ([artifactName, artifact ], error) => {
+      if(isPersistedAsTable(artifact))
+        error(null, ['definitions', artifactName], "Dropping tables is not supported");
+    }
+  }
+}
+
+const baseMatrix = {
+  // Integer types
+  'cds.hana.tinyint':['cds.UInt8', 'cds.Int16', 'cds.Int32', 'cds.Integer', 'cds.Int64', 'cds.Integer64'],
+  'cds.UInt8': ['cds.hana.tinyint', 'cds.Int16', 'cds.Int32', 'cds.Integer', 'cds.Int64', 'cds.Integer64'],
+  'cds.Int16': ['cds.hana.smallint', 'cds.Int32', 'cds.Integer', 'cds.Int64', 'cds.Integer64'],
+  'cds.hana.smallint':['cds.Int16', 'cds.Int32', 'cds.Integer', 'cds.Int64', 'cds.Integer64'],
+  'cds.Int32': ['cds.Integer', 'cds.Int64', 'cds.Integer64'],
+  'cds.Integer': ['cds.Int32', 'cds.Int64', 'cds.Integer64'],
+  'cds.Integer64': ['cds.Int64'],
+  'cds.Int64': ['cds.Integer64']
+}
+
+const allowedTypeChanges = {
+  'sqlite': baseMatrix
+};
+
+function typeChangeIsNotCompatible(dialect, before, after) {
+  if(allowedTypeChanges[dialect])
+    return allowedTypeChanges[dialect][before]?.indexOf(after) === -1;
+  return true;
+}

package/lib/optionProcessor.js

@@ -102,6 +102,9 @@ optionProcessor
                               hanaAssocRealCardinality
                               mapAssocToJoinCardinality
                               ignoreAssocPublishingInUnion
+                              enableUniversalCsn
+                              postgres
+                              aspectWithoutElements
                               odataOpenType
                               optionalActionFunctionParameters
        --deprecated <list>  Comma separated list of deprecated options.
@@ -142,6 +145,11 @@ optionProcessor
        manageConstraints [options] <files...>   (internal) Generate ALTER TABLE statements to
                                                            add / modify referential constraints.
        inspect [options] <files...>             (internal) Inspect the given CDS files.
+
+  Environment variables
+    NO_COLOR                If set, compiler messages (/output) will not be colored.
+                            Can be overwritten by '--color'
+    CDSC_TIMETRACING        If set, additional timing information is printed to stderr.
 `);
 
 // ----------- toHana -----------
@@ -257,7 +265,7 @@ optionProcessor.command('C, toCdl')
 optionProcessor.command('Q, toSql')
   .option('-h, --help')
   .option('-n, --sql-mapping <style>', ['plain', 'quoted', 'hdbcds'], { aliases: [ '--names' ] })
-  .option('-d, --sql-dialect <dialect>',  ['hana', 'sqlite', 'plain', 'postgres'], { aliases: [ '--dialect' ] })
+  .option('-d, --sql-dialect <dialect>',  ['hana', 'sqlite', 'plain', 'postgres', 'h2'], { aliases: [ '--dialect' ] })
   .option('    --render-virtual')
   .option('    --joinfk')
   .option('-u, --user <user>')
@@ -295,6 +303,7 @@ optionProcessor.command('Q, toSql')
                                 hana     : SQL with HANA specific language features
                                 sqlite   : Common SQL for sqlite
                                 postgres : Common SQL for postgres - beta-feature
+                                h2       : Common SQL for h2
    -u, --user <user>          Value for the "$user" variable
    -l, --locale <locale>      Value for the "$user.locale" variable in "sqlite"/"plain" dialect
    -s, --src <style>          Generate SQL source files as <artifact>.<suffix>

package/lib/render/manageConstraints.js

@@ -8,7 +8,7 @@ const {
 const { forEach } = require('../utils/objectUtils');
 const { makeMessageFunction } = require('../base/messages');
 const { optionProcessor } = require('../optionProcessor');
-const { transformForHanaWithCsn } = require('../transform/forHanaNew');
+const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 
 const {
   renderReferentialConstraint, getIdentifierUtils,
@@ -38,10 +38,12 @@ function alterConstraintsWithCsn(csn, options) {
   options.assertIntegrityType = 'DB';
 
   const transformedOptions = _transformSqlOptions(csn, options);
-  const forSqlCsn = transformForHanaWithCsn(csn, transformedOptions, 'to.sql');
+  const forSqlCsn = transformForRelationalDBWithCsn(csn, transformedOptions, 'to.sql');
 
-  if (violations && src && src !== 'sql')
-    error(null, null, `Option “--violations“ can't be combined with source style “${src}“`);
+  if (violations && src && src !== 'sql') {
+    error(null, null, { value: '--violations', othervalue: src },
+          'Option $(VALUE) can\'t be combined with source style $(OTHERVALUE)');
+  }
 
   let intermediateResult;
   if (violations)
@@ -67,12 +69,14 @@ function _transformSqlOptions(model, options) {
 
   if (options.sqlDialect !== 'hana') {
     // CDXCORE-465, 'quoted' and 'hdbcds' are to be used in combination with dialect 'hana' only
-    if (options.sqlMapping === 'quoted' || options.sqlMapping === 'hdbcds')
-      error(null, null, `Option "{ sqlDialect: '${options.sqlDialect}' }" can't be combined with "{ sqlMapping: '${options.sqlMapping}' }"`);
+    if (options.sqlMapping === 'quoted' || options.sqlMapping === 'hdbcds') {
+      error(null, null, { value: options.sqlDialect, othervalue: options.sqlMapping },
+            'Option sqlDialect: $(VALUE) can\'t be combined with sqlMapping: $(OTHERVALUE)');
+    }
 
     // No non-HANA SQL for HDI
     if (options.src === 'hdi')
-      error(null, null, `Option "{ sqlDialect: '${options.sqlDialect}' }" can't be used for HDI"`);
+      error(null, null, { value: options.sqlDialect }, 'Option sqlDialect: $(VALUE) can\'t be used for SAP HANA HDI');
   }
 
   return options;