@sap/cds-compiler 4.0.2 → 4.1.2

package/lib/render/toCdl.js

@@ -126,7 +126,7 @@ function csnToCdl( csn, options ) {
     return result;
 
     function renderVocabulariesEntry( name, anno ) {
-      if (!anno._ignore) {
+      if (!anno.$ignore) {
         // This environment is passed down the call hierarchy, for dealing with
         // indentation and name resolution issues
         const env = createEnv({ path: [ 'vocabularies', name ] });
@@ -512,8 +512,15 @@ function csnToCdl( csn, options ) {
       result += renderParameters(art, env);
     if (art.includes)
       result += renderIncludes(art.includes, env);
-    result += ` ${renderElements(art, env)}`;
+
+    if (art.elements)
+      result += ` ${renderElements(art, env)}`;
+    else if (art.actions)
+      // if there are no elements, but actions, CDL syntax requires braces.
+      result += ' { }';
+
     result += `${renderActionsAndFunctions(art, env)};\n`;
+
     return result;
   }
 
@@ -565,7 +572,7 @@ function csnToCdl( csn, options ) {
    * Returns the resulting source string.
    *
    * @param {string} elementName
-   * @param {CSN.Element|CSN.Enum} element
+   * @param {CSN.Element} element
    * @param {CdlRenderEnvironment} env
    */
   function renderElement( elementName, element, env ) {
@@ -1037,7 +1044,7 @@ function csnToCdl( csn, options ) {
       result += `${env.indent}}`;
     }
 
-    if (isLeadingQuery)
+    if (isLeadingQuery && query.actions)
       result += renderActionsAndFunctions(query, env);
 
     if (select.where)
@@ -1148,14 +1155,14 @@ function csnToCdl( csn, options ) {
    */
   function renderActionsAndFunctions( art, env ) {
     let result = '';
-    const childEnv = env.withIncreasedIndent();
-    for (const name in art.actions)
-      result += renderActionOrFunction(name, art.actions[name], childEnv.withSubPath([ 'actions', name ]));
-
-    // Even if we have seen actions/functions, they might all have been ignored
-    if (result !== '')
-      result = ` actions {\n${result}${env.indent}}`;
-
+    if (art.actions) {
+      const childEnv = env.withIncreasedIndent();
+      for (const name in art.actions)
+        result += renderActionOrFunction(name, art.actions[name], childEnv.withSubPath([ 'actions', name ]));
+      result = (result === '')
+        ? ' actions { }'
+        : ` actions {\n${result}${env.indent}}`;
+    }
     return result;
   }
 
@@ -1232,10 +1239,15 @@ function csnToCdl( csn, options ) {
     if (art.includes)
       result += renderIncludes(art.includes, env);
 
-    if (!art.type && art.elements) // For nicer output, no colon if unnamed structure is used.
-      result += ` ${renderTypeReferenceAndProps(art, env)}`;
-    else
-      result += ` : ${renderTypeReferenceAndProps(art, env)}`;
+    const type = renderTypeReferenceAndProps(art, env);
+    if (type) {
+      // For nicer output, no colon if unnamed structure is used.
+      result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
+    }
+    else {
+      msg.warning('syntax-missing-type', env.path, { name: artifactName },
+                  'Missing type for definition $(NAME); can\'t be represented in CDL');
+    }
     result += ';\n';
     return result;
   }
@@ -1310,8 +1322,9 @@ function csnToCdl( csn, options ) {
 
       if (artifact.notNull !== undefined && !artifact.on) // unmanaged associations can't be followed by "not null"
         result += renderNullability(artifact);
-      // DEFAULT not possible here.
 
+      if (artifact.default && !artifact.on)
+        result += ` default ${exprRenderer.renderExpr(artifact.default, env.withSubPath([ 'default' ]))}`;
       return result;
     }
 
@@ -1814,7 +1827,7 @@ function csnToCdl( csn, options ) {
     // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
     const parts = name.split('#');
     const nameBeforeVariant = parts[0];
-    const variant = parts[1];
+    const variant = parts.length > 1 ? parts.slice(1).join('#') : undefined;
     const { parentheses } = config;
 
     let result = `${env.indent}@`;
@@ -1822,10 +1835,11 @@ function csnToCdl( csn, options ) {
       result += '(';
 
     result += quoteAnnotationPathIfRequired(nameBeforeVariant, env);
-    if (variant !== undefined)
+    if (variant !== undefined) {
       // Unfortunately, the compiler does not allow `.@` after the first variant identifier,
-      // so we're back at simple paths.
+      // nor multiple `#`, so we're back at simple paths that are possibly quoted.
       result += `#${quotePathIfRequired(variant, env)}`;
+    }
     result += ` : ${renderAnnotationValue(anno, env)}`;
 
     if (parentheses)

package/lib/render/toHdbcds.js

@@ -647,7 +647,7 @@ function toHdbcdsSource( csn, options ) {
     // Because we already emit an error that calc-on-write is not supported, just ignore nullability/default.
     if (!elm.value?.stored) {
       result += renderNullability(elm);
-      if (elm.default)
+      if (elm.default && !elm.target)
         result += ` default ${renderExpr(elm.default, env.withSubPath([ 'default' ]))}`;
     }
 
@@ -798,7 +798,7 @@ function toHdbcdsSource( csn, options ) {
 
       const key = (!env.skipKeys && (col.key || element?.key) ? 'key ' : '');
       result += key + renderExpr(withoutCast(col), env);
-      let alias = col.as || col.func;
+      let alias = col.as || (!col.args && col.func); // func: e.g. CURRENT_TIMESTAMP
       // HANA requires an alias for 'key' columns just for syntactical reasons
       // FIXME: This will not complain for non-refs (but that should be checked in forRelationalDB)
       // Explicit or implicit alias?

package/lib/render/toRename.js

@@ -5,15 +5,11 @@ const { makeMessageFunction } = require('../base/messages');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { forEachDefinition } = require('../model/csnUtils');
 const { optionProcessor } = require('../optionProcessor');
-const { isBetaEnabled } = require('../base/model');
 const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 const { getIdentifierUtils } = require('./utils/sql');
 
 
 /**
- * FIXME: Not yet supported, only in beta mode
- * FIXME: This is not up-to-date in regards to the changes to hdbcds/sql quoting etc.
- *
  * Generate SQL DDL rename statements for a migration, renaming existing tables and their
  * columns so that they match the result of "toHana" or "toSql" with the 'plain' option for names.
  * Expects the naming convention of the existing tables to be either 'quoted' or 'hdbcds' (default).
@@ -32,7 +28,7 @@ const { getIdentifierUtils } = require('./utils/sql');
  * @returns {object} A dictionary of name: rename statement
  */
 function toRename( inputCsn, options ) {
-  const { error, warning, throwWithError } = makeMessageFunction(inputCsn, options, 'to.rename');
+  const { warning, throwWithError } = makeMessageFunction(inputCsn, options, 'to.rename');
 
   // Merge options with defaults.
   options = Object.assign({ sqlMapping: 'hdbcds', sqlDialect: 'hana' }, options);
@@ -41,9 +37,8 @@ function toRename( inputCsn, options ) {
   optionProcessor.verifyOptions(options, 'toRename').forEach(complaint => warning(null, null, `${complaint}`));
   checkCSNVersion(inputCsn, options);
 
-  // Requires beta mode
-  if (!isBetaEnabled(options, 'toRename'))
-    error(null, null, 'Generation of SQL rename statements is not supported yet (only in beta mode)');
+  // Let users know that this is internal
+  warning(null, null, 'Generation of SQL rename statements is a beta feature and might change in the future');
 
   // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forRelationalDB)
   const csn = transformForRelationalDBWithCsn(inputCsn, options, 'to.rename');
@@ -102,7 +97,7 @@ function toRename( inputCsn, options ) {
         const beforeColumnName = hdbcdsOrQuotedIdentifiers.quoteSqlId(name);
         const afterColumnName = plainIdentifiers.quoteSqlId(name);
 
-        if (!e._ignore) {
+        if (!e.$ignore) {
           if (e.target)
             str = `  EXEC 'ALTER TABLE ${afterTableName} DROP ASSOCIATION ${beforeColumnName}';\n`;
           else if (beforeColumnName.toUpperCase() === `"${afterColumnName}"` ) // Basically a no-op - render commented out

package/lib/render/toSql.js

@@ -24,7 +24,8 @@ const { timetrace } = require('../utils/timetrace');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { smartFuncId } = require('../sql-identifier');
 const { sortCsn } = require('../json/to-csn');
-const { manageConstraints } = require('./manageConstraints');
+const { manageConstraints, manageConstraint } = require('./manageConstraints');
+const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
 const { ModelError, CompilerAssertion } = require('../base/error');
 
 class SqlRenderEnvironment {
@@ -105,6 +106,7 @@ function toSqlDdl( csn, options ) {
     error, warning, info, throwWithAnyError,
   } = makeMessageFunction(csn, options, 'to.sql');
   const { quoteSqlId, prepareIdentifier, renderArtifactName } = getIdentifierUtils(csn, options);
+  let reportedMissingUserReplacement = false;
 
   const exprRenderer = createExpressionRenderer({
     // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
@@ -175,6 +177,7 @@ function toSqlDdl( csn, options ) {
     hdbview: Object.create(null),
     hdbconstraint: Object.create(null),
     deletions: Object.create(null),
+    constraintDeletions: [],
     migrations: Object.create(null),
   };
 
@@ -240,8 +243,10 @@ function toSqlDdl( csn, options ) {
   const sqlVersionLine = `-- ${generatedByCompilerVersion()}\n`;
 
   // Handle hdbKinds separately from alterTable case
-  // eslint-disable-next-line no-unused-vars
-  const { deletions, migrations: _, ...hdbKinds } = mainResultObj;
+  const {
+    // eslint-disable-next-line no-unused-vars
+    deletions, constraintDeletions, migrations: _, ...hdbKinds
+  } = mainResultObj;
   for (const hdbKind of Object.keys(hdbKinds)) {
     for (const name in mainResultObj[hdbKind]) {
       if (options.src === 'sql') {
@@ -260,14 +265,15 @@ function toSqlDdl( csn, options ) {
   }
 
   // add `ALTER TABLE ADD CONSTRAINT` statements per default for `to.sql` w/ dialect `hana` / `postgres`
-  // TODO `ALTER TABLE ADD CONSTRAINT` statements also for sqlite constraints
   if (!options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres' /* || options.sqlDialect === 'sqlite' */)) {
+    const constraints = Object.create(null);
     const alterStmts = manageConstraints(csn, options);
 
     forEachKey(alterStmts, (constraintName) => {
-      sql[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
+      if (!csn.unchangedConstraints?.has(constraintName))
+        constraints[constraintName] = `${options.testMode ? '' : sqlVersionLine}${alterStmts[constraintName]}`;
     });
-    mainResultObj.sql = sql;
+    mainResultObj.constraints = constraints;
   }
 
   if (options.src === 'sql')
@@ -333,8 +339,12 @@ function toSqlDdl( csn, options ) {
   function renderArtifactExtensionInto( artifactName, artifact, ext, resultObj, env ) {
     // Property kind is always omitted for elements and can be omitted for
     // top-level type definitions, it does not exist for extensions.
-    if (artifactName && !ext.query)
-      renderExtendInto(artifactName, artifact.elements, ext.elements, resultObj, env, extensionsDuplicateChecker);
+    if (artifactName && !ext.query) {
+      if (ext.constraint)
+        renderConstraintExtendInto(artifactName, ext, resultObj);
+      else
+        renderExtendInto(artifactName, artifact.elements, ext.elements, resultObj, env, extensionsDuplicateChecker);
+    }
 
     if (!artifactName)
       throw new ModelError(`Undefined artifact name: ${artifactName}`);
@@ -421,6 +431,24 @@ function toSqlDdl( csn, options ) {
       }
     }
 
+    if (migration.removeConstraints) {
+      const constraintTypes = [ 'unique', 'referential' ];
+      constraintTypes.forEach((constraintType) => {
+        if (migration.removeConstraints[constraintType]) {
+          const entries = Object.entries(migration.removeConstraints[constraintType]);
+          const optionsWithDrop = { ...options, drop: true };
+          let renderer;
+          if (constraintType === 'referential')
+            renderer = constraint => manageConstraint(constraint, csn, optionsWithDrop, '', quoteSqlId);
+          else
+            renderer = (constraint, constraintName) => renderUniqueConstraintDrop(constraint, renderArtifactName(`${artifactName}_${constraintName}`), tableName, quoteSqlId);
+          entries.forEach(( [ constraintName, constraint ]) => {
+            addConstraintDeletion(resultObj, constraint.parentTable, renderer(constraint, constraintName));
+          });
+        }
+      });
+    }
+
     // Change column types (unsupported in sqlite)
     if (migration.change) {
       changeElementsDuplicateChecker.addArtifact(tableName, undefined, artifactName);
@@ -550,16 +578,11 @@ function toSqlDdl( csn, options ) {
     // OR create a unique index for HDI
     const uniqueConstraints = art.$tableConstraints && art.$tableConstraints.unique;
     for (const cn in uniqueConstraints) {
-      const c = uniqueConstraints[cn];
-      const cnName = renderArtifactName(`${artifactName}_${cn}`);
-      const refs = c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ');
-      if (options.src === 'hdi') {
-        resultObj.hdbindex[`${artifactName}.${cn}`]
-          = `UNIQUE INVERTED INDEX ${cnName} ON ${tableName} (${refs})`;
-      }
-      else {
-        result += `,\n${childEnv.indent}CONSTRAINT ${cnName} UNIQUE (${refs})`;
-      }
+      const constraint = renderUniqueConstraintString(uniqueConstraints[cn], renderArtifactName(`${artifactName}_${cn}`), tableName, quoteSqlId, options);
+      if (options.src === 'hdi')
+        resultObj.hdbindex[`${artifactName}.${cn}`] = constraint;
+      else
+        result += `,\n${childEnv.indent}${constraint}`;
     }
     result += `${env.indent}\n)`;
 
@@ -591,6 +614,21 @@ function toSqlDdl( csn, options ) {
     resultObj.hdbtable[artifactName] = result;
   }
 
+  /**
+   * Render an extended entity constraint into the appropriate dictionaries of 'resultObj'.
+   * Only SAP HANA SQL is currently supported.
+   *
+   * @param {string} artifactName Name of the artifact to render
+   * @param {object} ext Constraint comprising the extension
+   * @param {object} resultObj Result collector
+   */
+  function renderConstraintExtendInto( artifactName, { constraint, constraintName, constraintType }, resultObj ) {
+    const result = constraintType === 'unique' ? renderUniqueConstraintAdd(constraint, renderArtifactName(`${artifactName}_${constraintName}`), renderArtifactName(constraint.parentTable), quoteSqlId, options)
+      : manageConstraint(constraint, csn, options, '', quoteSqlId);
+
+    addMigration(resultObj, artifactName, false, [ result ]);
+  }
+
 
   /**
    * Render an extended entity into the appropriate dictionaries of 'resultObj'.
@@ -632,6 +670,9 @@ function toSqlDdl( csn, options ) {
     resultObj.migrations[artifactName].push(...migrations);
   }
 
+  function addConstraintDeletion( resultObj, artifactName, deletionSql ) {
+    resultObj.constraintDeletions.push(deletionSql);
+  }
   function addDeletion( resultObj, artifactName, deletionSql ) {
     resultObj.deletions[artifactName] = deletionSql;
   }
@@ -1064,7 +1105,7 @@ function toSqlDdl( csn, options ) {
       result = env.indent + renderExpr(withoutCast(col), env);
       if (col.as)
         result += ` AS ${quoteSqlId(col.as)}`;
-      else if (col.func)
+      else if (col.func && !col.args) // e.g. CURRENT_TIMESTAMP
         result += ` AS ${quoteSqlId(col.func)}`;
     }
     return result;
@@ -1466,9 +1507,8 @@ function toSqlDdl( csn, options ) {
           case 'hana':
             return 'CURRENT_TIMESTAMP';
           case 'h2':
-            return 'current_timestamp';
           case 'postgres':
-            return '(current_timestamp at time zone \'UTC\')';
+            return 'current_timestamp';
           default:
             return quoteSqlId(x.ref[0]);
         }
@@ -1498,19 +1538,28 @@ function toSqlDdl( csn, options ) {
       if (options.sqlDialect === 'hana')
         return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
       else if (options.sqlDialect === 'postgres')
-        return 'current_setting(\'CAP.APPLICATIONUSER\')';
+        return 'current_setting(\'cap.applicationuser\')';
       else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
         return 'session_context( \'$user.id\' )';
-      warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
+      else if (options.sqlDialect === 'h2')
+        return '@applicationuser';
+
+      if (!reportedMissingUserReplacement) {
+        warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
+        reportedMissingUserReplacement = true;
+      }
       return '\'$user.id\'';
     }
     else if (x.ref[1] === 'locale') {
       if (options.sqlDialect === 'hana')
         return 'SESSION_CONTEXT(\'LOCALE\')';
       else if (options.sqlDialect === 'postgres')
-        return 'current_setting(\'CAP.LOCALE\')';
+        return 'current_setting(\'cap.locale\')';
       else if (options.betterSqliteSessionVariables && options.sqlDialect === 'sqlite')
         return 'session_context( \'$user.locale\' )';
+      else if (options.sqlDialect === 'h2')
+        return '@locale';
+
       return '\'en\''; // default language
     }
     // Basically: Second path step was invalid, do nothing - should not happen.
@@ -1542,8 +1591,9 @@ function toSqlDdl( csn, options ) {
         case 'hana':
           return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
         case 'postgres':
-          return '(to_timestamp(current_setting(\'CAP.VALID_FROM\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+          return 'current_setting(\'cap.valid_from\')::timestamp';
         case 'h2':
+          return '@valid_from';
         case 'plain':
           return 'current_timestamp';
         default:
@@ -1563,8 +1613,9 @@ function toSqlDdl( csn, options ) {
         case 'hana':
           return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
         case 'postgres':
-          return '(to_timestamp(current_setting(\'CAP.VALID_TO\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
+          return 'current_setting(\'cap.valid_to\')::timestamp';
         case 'h2':
+          return '@valid_to';
         case 'plain':
           return 'current_timestamp';
         default:

package/lib/render/utils/common.js

@@ -146,7 +146,7 @@ function addContextMarkers( csn, killList ) {
   const contextsToCreate = Object.create(null);
   forEachDefinition(csn, (art, artifactName) => {
     const namespace = getNamespace(csn, artifactName);
-    if (namespace && !(art._ignore || hasValidSkipOrExists(art))) {
+    if (namespace && !(art.$ignore || hasValidSkipOrExists(art))) {
       const parts = namespace.split('.');
       contextsToCreate[parts[0]] = true;
 
@@ -204,7 +204,7 @@ function addMissingChildContexts( csn, artifactName, killList ) {
   const possibleNames = Object.keys(csn.definitions).filter(name => name.startsWith(`${artifactName}.`)).sort((a, b) => a.length - b.length);
   for (const name of possibleNames) {
     const artifact = csn.definitions[name];
-    if (!artifact._ignore && !hasValidSkipOrExists(artifact))
+    if (!artifact.$ignore && !hasValidSkipOrExists(artifact))
       addPossibleGaps(name.slice(artifactName.length + 1).split('.'), artifactName);
   }
 
@@ -360,7 +360,7 @@ function findElement( elements, column ) {
 function addIntermediateContexts( csn, killList ) {
   for (const artifactName in csn.definitions) {
     const artifact = csn.definitions[artifactName];
-    if ((artifact.kind === 'context') && !artifact._ignore) {
+    if ((artifact.kind === 'context') && !artifact.$ignore) {
       // If context A.B.C and entity A exist, we still need generate context A_B.
       // But if no entity A exists, A.B is just a namespace.
       // For case 1 and 2, getParentContextName returns undefined - we then use the namespace as our "off-limits"

package/lib/render/utils/unique.js

@@ -0,0 +1,52 @@
+'use strict';
+
+/**
+ * Render the "CONSTRAINT <XY>;" for HDI or SQL.
+ *
+ * @param {object} constraint The constraint to add
+ * @param {string} constraintName Name of the constraint - needs to be escaped on caller side
+ * @param {string} tableName Name of the table with the constraint - needs to be escaped on caller side
+ * @param {function} quoteSqlId Usual rendering function
+ * @param {object} options Options
+ * @returns {string}
+ */
+function renderUniqueConstraintString( constraint, constraintName, tableName, quoteSqlId, options ) {
+  const c = constraint.paths;
+  const refs = c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ');
+  if (options.src === 'hdi')
+    return `UNIQUE INVERTED INDEX ${constraintName} ON ${tableName} (${refs})`;
+
+  return `CONSTRAINT ${constraintName} UNIQUE (${refs})`;
+}
+/**
+ * Render the "ALTER TABLE XY DROP CONSTRAINT <Z>;"
+ *
+ * @param {object} constraint The constraint to drop
+ * @param {string} constraintName Name of the constraint - needs to be escaped on caller side
+ * @param {string} tableName Name of the table with the constraint - needs to be escaped on caller side
+ * @param {function} quoteSqlId Usual rendering function
+ * @returns {string}
+ */
+function renderUniqueConstraintDrop( constraint, constraintName, tableName, quoteSqlId ) {
+  return `ALTER TABLE ${tableName} DROP CONSTRAINT ${quoteSqlId(constraintName)};`;
+}
+
+/**
+ * Render the "ALTER TABLE XY ADD CONSTRAINT <Z>;"
+ *
+ * @param {object} constraint The constraint to add
+ * @param {string} constraintName Name of the constraint - needs to be escaped on caller side
+ * @param {string} tableName Name of the table with the constraint - needs to be escaped on caller side
+ * @param {function} quoteSqlId Usual rendering function
+ * @param {object} options Options
+ * @returns {string}
+ */
+function renderUniqueConstraintAdd( constraint, constraintName, tableName, quoteSqlId, options ) {
+  return `ALTER TABLE ${tableName} ADD ${renderUniqueConstraintString(constraint, constraintName, tableName, quoteSqlId, options)};`;
+}
+
+module.exports = {
+  renderUniqueConstraintString,
+  renderUniqueConstraintDrop,
+  renderUniqueConstraintAdd,
+};

package/lib/transform/db/applyTransformations.js

@@ -1,6 +1,6 @@
 'use strict';
 
-/**
+/*
  * Module for general (partial) CSN looper functions, respecting dictionaries and allowing
  * to pass custom callbacks for certain properties like "ref".
  *
@@ -10,6 +10,8 @@
  *
  * @module lib/transform/db/applyTransformations
  */
+
+
 const { setProp } = require('../../base/model');
 
 
@@ -18,11 +20,17 @@ const { setProp } = require('../../base/model');
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
  * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {applyTransformationsOptions} [options={}]
+ * @param {applyTransformationsOptions} [_options={}]
  * @param {CSN.Path} path Path to parent
  * @returns {object} parent with transformations applied
  */
-function applyTransformationsInternal( parent, prop, customTransformers, artifactTransformers, options, path = [] ) {
+function applyTransformationsInternal( parent, prop, customTransformers, artifactTransformers, _options, path = [] ) {
+  const options = { ..._options };
+  if (!options.skipStandard)
+    options.skipStandard = { $tableConstraints: true };
+  else if (options.skipStandard.$tableConstraints === undefined)
+    options.skipStandard = { ...options.skipStandard, ...{ $tableConstraints: true } };
+
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -43,12 +51,13 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
       standard( parent, name, parent[name] );
   }
   else {
-    standard(parent, prop, parent[prop]);
+    standard( parent, prop, parent[prop] );
   }
   return parent;
 
   /**
-   * Default transformer for things that are not dictionaries, like "type" or "keys".
+   * Default transformer for things that are not dictionaries or dictionary entries,
+   * such as "type" or "keys".
    * The customTransformers are applied here (and only here).
    *
    * @param {object | Array} _parent the thing that has _prop
@@ -59,7 +68,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     if (!node || typeof node !== 'object' ||
         !{}.propertyIsEnumerable.call( _parent, _prop ) ||
         (typeof _prop === 'string' && _prop.startsWith('@')) ||
-        (options.skipIgnore && node._ignore) ||
+        (options.skipIgnore && node.$ignore) ||
         options.skipStandard?.[_prop]
     )
       return;
@@ -75,13 +84,35 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
         const trans = transformers[name] || standard;
         if (customTransformers[name])
           customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
-
         trans( node, name, node[name], csnPath );
       }
     }
     csnPath.pop();
   }
 
+  /**
+   * Transformer for dictionary entries.  Similar to standard(), but does not filter
+   * based on the given name.  Otherwise, `options.skipStandards` could accidentally skip
+   * dictionary entries (e.g. entity called `@Name`).
+   *
+   * @param {object | Array} dict the thing that has _prop
+   * @param {string|number} entryName the name of the current property
+   * @param {object} node The value of node[_prop]
+   */
+  function dictEntry( dict, entryName, node ) {
+    if (!node || typeof node !== 'object' || (options.skipIgnore && node.$ignore))
+      return;
+
+    csnPath.push( entryName );
+    for (const name of Object.getOwnPropertyNames( node )) {
+      const trans = transformers[name] || standard;
+      if (customTransformers[name])
+        customTransformers[name](node, name, node[name], csnPath, dict);
+      trans( node, name, node[name], csnPath );
+    }
+    csnPath.pop();
+  }
+
   /**
    * Transformer for things that are dictionaries - like "elements".
    *
@@ -90,12 +121,12 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
    * @param {object} dict The value of node[_prop]
    */
   function dictionary( node, _prop, dict ) {
-    // Allow skipping dicts like actions in forRelationalDB
-    if (options.skipDict && options.skipDict[_prop] || dict === null || dict === undefined) // with universal CSN, dicts might be null
+    // Allow skipping dictionaries like actions in forRelationalDB
+    if (options.skipDict?.[_prop] || dict == null) // with universal CSN, dictionaries might be null
       return;
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict ))
-      standard( dict, name, dict[name] );
+      dictEntry( dict, name, dict[name] );
 
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
       setProp(node, `$${_prop}`, dict);
@@ -112,13 +143,9 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
   function definitions( node, _prop, dict ) {
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict )) {
-      const skip = (options && options.allowArtifact && !options.allowArtifact(dict[name], name)) ||
-                   (options && options.skipArtifact && options.skipArtifact(dict[name], name)) ||
-                   (options && options.skip && options.skip.includes(dict[name].kind)) ||
-                   false;
-      if (!skip) {
+      if (!isArtifactSkipped( dict, name )) {
         artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
-        standard( dict, name, dict[name] );
+        dictEntry( dict, name, dict[name] );
       }
     }
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
@@ -126,6 +153,20 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     csnPath.pop();
   }
 
+  /**
+   * Whether the given artifact `dict[name]` is skipped via options.
+   *
+   * @param {object} dict
+   * @param {string} name
+   * @returns {boolean}
+   */
+  function isArtifactSkipped( dict, name ) {
+    return options && ((options.allowArtifact && !options.allowArtifact(dict[name], name)) ||
+        (options.skipArtifact && options.skipArtifact(dict[name], name)) ||
+        (options.skip?.includes(dict[name].kind))) ||
+      false;
+  }
+
   /**
    * Keep looping through the pathRef - because in a .ref we can have .args and .where
    *
@@ -173,7 +214,7 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
   if (options.skipIgnore === undefined)
     options.skipIgnore = true;
 
-  if (csn && csn.definitions)
+  if (csn?.definitions)
     return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, options);
   return csn;
 }
@@ -230,12 +271,12 @@ module.exports = {
 
 /**
  * @typedef {object} applyTransformationsOptions
- * @property {(artifact, name) => boolean} [allowArtifact] to only allow certain artifacts
- * @property {(artifact, name) => boolean} [skipArtifact] to skip certain artifacts
+ * @property {(artifact: CSN.Artifact, name: string) => boolean} [allowArtifact] to only allow certain artifacts
+ * @property {(artifact: CSN.Artifact, name: string) => boolean} [skipArtifact] to skip certain artifacts
  * @property {boolean} [drillRef] whether to drill into infix/args
  * @property {string[]} [skip] skip definitions from certain kind
  * @property {object} [skipStandard] stop drill-down on certain "standard" props
  * @property {object} [skipDict] stop drill-down on certain "dictionary" props
- * @property {boolean} [skipIgnore=true] Whether to skip _ignore elements or not
+ * @property {boolean} [skipIgnore=true] Whether to skip $ignore elements or not
  * @property {boolean} [directDict=false] Implicitly set via applyTransformationsOnDictionary
  */