@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/transform/forOdataNew.js

@@ -60,7 +60,7 @@ const { addLocalizationViews } = require('./localized');
 //   - Mark fields with @odata.on.insert/update as @Core.Computed
 //     (EdmPreproc candidate, check with RT if @Core.Computed required by them)
 //   - Rename shorthand annotations according to a builtin list (EdmPreproc Candidate)
-//       e.g. @label -> @Common.Label or @important: [true|false] -> @UI.Importance: [#High|#Low]
+//       e.g. @label -> @Common.Label
 //   - If the association target is annotated with @cds.odata.valuelist, annotate the
 //        association with @Common.ValueList.viaAssociation (EdmPreproc Candidate)
 //   - Check for @Analytics.Measure and @Aggregation.default (Linter check candidate, remove)
@@ -315,31 +315,36 @@ function transform4odataWithCsn(inputModel, options) {
   // list.
   function renameShorthandAnnotations(node) {
     // FIXME: Verify this list - are they all still required? Do we need any more?
-    const mappings = {
+    const setMappings = {
       '@label': '@Common.Label',
       '@title': '@Common.Label',
       '@description': '@Core.Description',
+    };
+    const renameMappings = {
       '@ValueList.entity': '@Common.ValueList.entity',
       '@ValueList.type': '@Common.ValueList.type',
       '@Capabilities.Deletable': '@Capabilities.DeleteRestrictions.Deletable',
       '@Capabilities.Insertable': '@Capabilities.InsertRestrictions.Insertable',
       '@Capabilities.Updatable': '@Capabilities.UpdateRestrictions.Updatable',
       '@Capabilities.Readable': '@Capabilities.ReadRestrictions.Readable',
-    }
+    };
 
-    const shortCuts = Object.keys(mappings);
+    const setShortCuts = Object.keys(setMappings);
+    const renameShortCuts = Object.keys(renameMappings);
     Object.keys(node).forEach( name => {
+      if (!name.startsWith('@'))
+        return;
       // Rename according to map above
-      const prefix = shortCuts.find(p => name.startsWith(p + '.') || name === p);
-      if(prefix) {
-        renameAnnotation(node, name, name.replace(prefix, mappings[prefix]));
-      }
-      // Special case: '@important: [true|false]' becomes '@UI.Importance: [#High|#Low]'
-      if (name === '@important') {
-        renameAnnotation(node, name, '@UI.Importance');
-        let annotation = node['@UI.Importance'];
-        if (annotation !== null)
-          node['@UI.Importance'] = { '#': annotation ? 'High' : 'Low' };
+      const renamePrefix = (name in renameMappings) ? name : renameShortCuts.find(p => name.startsWith(p + '.'));
+      if(renamePrefix) {
+        renameAnnotation(node, name, name.replace(renamePrefix, renameMappings[renamePrefix]));
+      } else {
+        // The two mappings have no overlap, so no need to check for second map if first matched.
+        // Rename according to map above
+        const setPrefix = (name in setMappings) ? name : setShortCuts.find(p => name.startsWith(p + '.'));
+        if(setPrefix) {
+          setAnnotation(node, name.replace(setPrefix, setMappings[setPrefix]), node[name]);
+        }
       }
 
       // Special case: '@readonly' becomes a triplet of capability restrictions for entities,
@@ -351,7 +356,7 @@ function transform4odataWithCsn(inputModel, options) {
             setAnnotation(node, '@Capabilities.InsertRestrictions.Insertable', false);
             setAnnotation(node, '@Capabilities.UpdateRestrictions.Updatable', false);
           } else {
-            renameAnnotation(node, name, '@Core.Computed');
+            setAnnotation(node, '@Core.Computed', true);
           }
         }
         // @insertonly is effective on entities/queries only

package/lib/transform/forRelationalDB.js

@@ -9,7 +9,7 @@ const { cloneCsnNonDict,
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtilsNew');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
-const { csnRefs, pathId } = require('../model/csnRefs');
+const { csnRefs, pathId, traverseQuery } = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
@@ -18,6 +18,7 @@ const { timetrace } = require('../utils/timetrace');
 const { createReferentialConstraints, assertConstraintIdentifierUniqueness } = require('./db/constraints');
 const { createDict, forEach } = require('../utils/objectUtils');
 const handleExists = require('./db/transformExists');
+const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('./db/rewriteCalculatedElements');
 const replaceAssociationsInGroupByOrderBy = require('./db/groupByOrderBy');
 const _forEachDefinition = require('../model/csnUtils').forEachDefinition;
 const flattening = require('./db/flattening');
@@ -126,8 +127,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     get$combined,
     getCsnDef,
     isAssocOrComposition,
-    addStringAnnotationTo,
-    cloneWithTransformations;
+    addStringAnnotationTo;
   // transformUtils
   let addDefaultTypeFacets,
     expandStructsInExpression,
@@ -174,18 +174,17 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   throwWithAnyError();
 
-  // FIXME: This does something very similar to cloneWithTransformations -> refactor?
   const transformCsn = transformUtils.transformModel;
 
+  forEachDefinition(csn, [
+    // (001) Add a temporal where condition to views where applicable before assoc2join
+    //       assoc2join eventually rewrites the table aliases
+    temporal.getViewDecorator(csn, {info}, csnUtils),
+    // check unique constraints - further processing is done in rewriteUniqueConstraints
+    assertUnique.prepare(csn, options, error, info)
+  ]);
 
-  timetrace.start('temporal');
-  // (001) Add a temporal where condition to views where applicable before assoc2join
-  //       assoc2join eventually rewrites the table aliases
-  forEachDefinition(csn, temporal.getViewDecorator(csn, {info}, csnUtils));
-  timetrace.stop('temporal');
-
-  // check unique constraints - further processing is done in rewriteUniqueConstraints
-  assertUnique.prepare(csn, options, error, info);
+  rewriteCalculatedElementsInViews(csn, options, pathDelimiter, error);
 
   if(doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
@@ -199,6 +198,11 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   bindCsnReferenceOnly();
 
 
+  // TODO: Instead of 3 separate applyTransformations, we could have each of them just return the "listeners", merge them into
+  // one big listener that then gets passed into one single applyTransformations. Each listener would then have to return an array of callbacks to call.
+  // With that, we could still ensure the processing order (assuming we don't run into problems with scoping).
+  // To analyze: Increased memory vs. saved cycles
+  // Looked at it with AFC: This is only a small part of the overall processing time, enrich step of validator is just as expensive
   if(doA2J) {
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
@@ -240,6 +244,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     }
   });
 
+  processCalculatedElementsInEntities(csn, options);
+
   timetrace.start('Transform CSN')
 
   // (000) Rename primitive types, make UUID a String
@@ -255,15 +261,15 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     },
   }, true);
 
-  // (040) Ignore entities and views that are abstract or implemented
-  // or carry the annotation cds.persistence.skip/exists
-  // These entities are not removed from the csn, but flagged as "to be ignored"
-  forEachDefinition(csn, cdsPersistence.getAnnoProcessor());
-
-
-  // (050) Check @cds.valid.from/to only on entity
-  //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
-  forEachDefinition(csn, temporal.getAnnotationHandler(csn, options, pathDelimiter, {error}));
+  forEachDefinition(csn, [
+    // (040) Ignore entities and views that are abstract or implemented
+    // or carry the annotation cds.persistence.skip/exists
+    // These entities are not removed from the csn, but flagged as "to be ignored"
+    cdsPersistence.getAnnoProcessor(),
+    // (050) Check @cds.valid.from/to only on entity
+    //       Views are checked in (001), unbalanced valid.from/to's or mismatching origins
+    temporal.getAnnotationHandler(csn, options, pathDelimiter, {error})
+  ]);
 
   // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
   doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, csnUtils, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
@@ -300,18 +306,19 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     }
   });
 
-  // For generating DB stuff:
-  // - table-entity with parameters: not allowed
-  // - view with parameters: ok on HANA, not allowed otherwise
-  // (don't complain about action/function with parameters)
-  forEachDefinition(csn, handleChecksForWithParameters);
-
-  // Remove .masked
-  // Check that keys are not explicitly nullable
-  // Check that Associations are not used in entities/views with parameters
-  // (150 b) Strip inheritance
-  // Note that this should happen after implicit redirection, because includes are required for that
-  forEachDefinition(csn, handleDBChecks);
+  forEachDefinition(csn, [
+    // For generating DB stuff:
+    // - table-entity with parameters: not allowed
+    // - view with parameters: ok on HANA, not allowed otherwise
+    // (don't complain about action/function with parameters)
+    handleChecksForWithParameters,
+    // Remove .masked
+    // Check that keys are not explicitly nullable
+    // Check that Associations are not used in entities/views with parameters
+    // (150 b) Strip inheritance
+    // Note that this should happen after implicit redirection, because includes are required for that
+    handleDBChecks,
+  ]);
 
   // (170) Transform '$self' in backlink associations to appropriate key comparisons
   // Must happen before draft processing because the artificial ON-conditions in generated
@@ -449,7 +456,6 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       getCsnDef,
       isAssocOrComposition,
       addStringAnnotationTo,
-      cloneWithTransformations
     } = csnUtils);
   }
 
@@ -530,6 +536,20 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     if (!artifact._ignore) {
       // Do things specific for entities and views (pass 2)
       if ((artifact.kind === 'entity') && artifact.query) {
+
+        // First pass: Set alias name for SELECTs without table alias. Required for setting proper table aliases
+        // for HDBCDS in naming mode HDBCDS.  We use the same schema as the core-compiler, so duplicates should
+        // have already been reported.
+        let selectDepth = 0;
+        traverseQuery(artifact.query, null, null, (query, fromSelect) => {
+          if (!query.ref && !query.as && fromSelect) {
+            // Use +1; for UNION, it's the next select, for SELECT, it's increased later.
+            query.as = `$_select_${selectDepth + 1}__`;
+          }
+          if (query.SELECT)
+            ++selectDepth;
+        });
+
         const process = (parent, prop, query, path) => {
           transformEntityOrViewPass2(parent, artifact, artifactName, path.concat(prop))
           replaceAssociationsInGroupByOrderBy(parent, options, inspectRef, error, path.concat(prop));
@@ -977,25 +997,22 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       // this is done in the flattening, but as we do not alter the onCond itself there should be done here as well
       elemName = elemName.replace(/\./g, pathDelimiter);
       const assocName = originalAssocName.replace(/\./g, pathDelimiter);
-      // clone the onCond for later use in the path transformation,
-      // also assign the _artifact elements of the path elements to the copy
-      const newOnCond = cloneWithTransformations(assoc.on, {
-        ref: (value) => cloneWithTransformations(value, {}),
-      });
+      // clone the onCond for later use in the path transformation
+      const newOnCond = cloneCsnNonDict(assoc.on, options);
       applyTransformationsOnNonDictionary({on: newOnCond}, 'on', {
         ref: (parent, prop, ref) => {
           if (ref[0] === assocName) // we are in the "path" from the forwarding assoc => need to remove the first part of the path
           {
             ref.shift();
           } else if(ref && ref.length > 1 && ref[0] === '$self' && ref[1] === assocName) {
-            // We could also have a $self infront of the assoc name - so we would need to shift twice
+            // We could also have a $self in front of the assoc name - so we would need to shift twice
             ref.shift();
             ref.shift();
           }
           else { // we are in the backlink assoc "path" => need to push at the beginning the association's id
             ref.unshift(elemName);
             // if there was a $self identifier in the forwarding association onCond
-            // we do not need it any more, as we prepended in the previous step the back association's id
+            // we do not need it anymore, as we prepended in the previous step the back association's id
             if (ref[1] === '$self')
               ref.splice(1, 1);
           }

package/lib/transform/odata/typesExposure.js

@@ -13,21 +13,66 @@ const { copyAnnotations, getNamespace } = require('../../model/csnUtils');
 const { isBetaEnabled } = require('../../base/model.js');
 const { CompilerAssertion } = require('../../base/error');
 
+/**
+ * A given CDS model is a set of n definitions D = {v_1, ..., v_n } spanning a type dependency
+ * graph T(D) with vertices v_r, v_d (representing the referrer (using) and defining node of a type)
+ * and edges e(v_r, v_d).
+ *
+ * S may be a proper subset of D and is defined by v_s. Up to n S_i may exist.
+ * v is element of S_i, if name(v) starts with name(v_s). Therefore any v can only be member
+ * of exactly one S_i and v_s is always member of its own S_i.
+ *
+ * A complete service type dependency graph Tc(S) is defined as a set of vertices v_r, v_d
+ * and edges e(v_r, v_d) such that all v_r, v_d are elements of S (v_rs, v_ds) and with that
+ * all edges are { e(v_rs, v_ds) }.
+ *
+ * The input CSN may contain edges e(v_rs, v_dns) with v_r element of S_i (v_rs) and v_d not element 
+ * of S_i (v_dns).
+ *
+ * The aim of this algorithm is to produce Tc's for all requested S_i by 'filling' up the missing
+ * vertices v_ds and rewriting all e(v_rs, v_dns) to e(v_rs, v_ds).
+ *
+ * This can be done pretty easily by (recursively) iterating over all requested v_rs and
+ * follow e(v_r, v_d) until a v_dns is found. v_dns is cloned and added to S via
+ * name(v_ds) = name(v_s) + '.' + name(v_dns). If v_dns is an anonymous definition, an
+ * artificial name representing the path to that node is being used.
+ *
+ * The algorithm has a beneficial side effect: it creates new (sub) schemas on the fly
+ * which are required for the construction of the EDM intermediate representation later on.
+ *
+ * An OData service contains at least one schema. Only (OData) schemas may contain definitions.
+ * By default, the CDS service v_s represents the default (OData) schema.
+ * However, there are situations where { v_dns } must be partitioned into (sub) schemas in order to
+ * maintain their original name prefixes and to be compatible with later service definitions.
+ *
+ * If name(v_dns) is made up of segments separated by a dot '.', the first n-1 segments represent
+ * the sub schema: name(schema) = name(v_s) + '.' + concat(1,n-1, segments(name(v_dns)), '.')
+ *
+ * If name(v_dns) has no prefix segments, the fallback schema name is prepended instead:
+ * name(v_ds) = name(v_s) + '.' + fallbackschema + name(v_dns);
+ * 
+ * @param {CSN.Model} csn
+ * @param {function}  whatsMyServiceName
+ * @param {string[]}     requestedServiceNames
+ * @param {String}    fallBackSchemaName
+ * @param {Object}    options
+ * @param {Object}    csnUtils
+ * @param {Object}    message
+ * @returns {Object}  schemas dictionary of (sub) schemas for all requested services
+ */
 function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackSchemaName, options, csnUtils, message) {
   const { error } = message;
   const special$self = !csn?.definitions?.$self && '$self';
   // are we working with OData proxies or cross-service refs
   const isMultiSchema = options.odataVersion === 'v4' && (options.odataProxies || options.odataXServiceRefs);
-  // collect in this variable all the newly exposed types
+  // service sub schemas as return value
   const schemas = Object.create(null);
+  // exposed types register
   const exposedTypes = Object.create(null);
-  // walk through the definitions of the given CSN and expose types where needed
   forEachDefinition(csn, (def, defName, propertyName, path) => {
-    // we do expose types only for definition from inside services
     const serviceName = whatsMyServiceName(defName, false);
     // run type exposure only on requested services if not in multi schema mode
     // multi schema mode requires a proper type exposure for all services as a prerequisite
-    // for the proxy exposure
     if (serviceName && requestedServiceNames.includes(serviceName)) {
       if (def.kind === 'type' || def.kind === 'entity') {
         forEachMember(def, (element, elementName, propertyName, path) => {
@@ -38,13 +83,9 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         }, path);
       }
 
-      // For exposed actions and functions that use non-exposed or anonymous structured types, create
-      // artificial exposing types.
-      // unbound actions
       if (def.kind === 'action' || def.kind === 'function') {
         exposeTypesOfAction(def, defName, defName, serviceName, path);
       }
-      // bound actions
       def.actions && Object.entries(def.actions).forEach(([actionName, action]) => {
         exposeTypesOfAction(action, `${defName}_${actionName}`, defName, serviceName, path.concat(['actions', actionName]));
       });
@@ -53,19 +94,13 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
 
   if(isBetaEnabled(options, 'odataTerms')) {
     forEachGeneric(csn, 'vocabularies', (def, defName, _propertyName, path) => {
-    // we do expose types only for definition from inside services
       const serviceName = whatsMyServiceName(defName, false);
-    // run type exposure only on requested services if not in multi schema mode
-    // multi schema mode requires a proper type exposure for all services as a prerequisite
-    // for the proxy exposure
       if (serviceName && requestedServiceNames.includes(serviceName)) {
         if(csn.definitions[defName]) {
-        // error, duplicate definitions not allowed!
-        // TODO: Use path as error location as soon as refs outside definitions are supported
           error('odata-definition-exists', ['vocabularies', defName], { anno: defName, '#':'anno' });
         }
         else {
-        // link def into definitions for later use
+          // link def into definitions for later use
           def.kind = 'annotation';
           csn.definitions[defName] = def;
           const artificialName = `term_${defName.replace(/\./g, '_')}`;//_${paramName}`;

package/lib/transform/parseExpr.js

@@ -19,7 +19,7 @@
  * Unary:                      'is [not] null', 'not'
  * Conditional:                'case [when then]+ [else]? end', 'and', 'or'
  *
- * Not yet implemented:        'new'
+ * stand-alone token:          'new'
  *
  * This is not an optimized LL(1) parser but a token 'sniffer'. A stream is
  * cracked up in sub streams and passed down to the next higher function.
@@ -33,8 +33,8 @@
  * This parser intentionally does no error handling. If a clause is malformed, it is accepted as is.
  *
  * @param {any} xpr A JSON object.
- * @param {Object} state Objet
- *  anno: Don't eliminate arrays with single entry in statetations as they are collections
+ * @param {Object} state Object
+ *  anno: Don't eliminate arrays with single entry in statetations (TODO?) as they are collections
  *  array: Bias AST representation.
  *  nary: return n-ary or binary tree
  */
@@ -42,7 +42,7 @@
 function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   // Notes:
   //  - Variables `s` and `e` are used as index variables into `xpr`s for start and end.
-  //  - xpr's are our CSN expressions, see <https://pages.github.tools.sap/cap/docs/cds/cxn>
+  //  - xpr's are our CSN expressions, see <https://cap.cloud.sap/docs/cds/cxn>
 
   return parseExprInt(xpr, state);
 
@@ -82,7 +82,7 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
      */
     function rewriteCaseBlock(casePos, endPos) {
       const caseTree = state.array ? [ 'case' ] : { 'case': [] };
-      
+
       let elsePos = endPos;
       let whenPos = casePos;
 
@@ -144,7 +144,7 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   function conditionOR(xpr, s, e, state) {
     return binaryExpr(xpr, ['or'], conditionAnd, s, e, state);
   }
-  
+
   function conditionAnd(xpr, s, e, state) {
     return binaryExpr(xpr, (xpr, s, e) => {
       let a = s-1;
@@ -283,7 +283,8 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
       //   return xpr;
       for(let n in xpr) {
         const x = xpr[n];
-        if(n[0] === '@')
+        const isAnno = n[0] === '@' && isSimpleAnnoValue(x);
+        if(isAnno)
           state.anno++;
         if(Array.isArray(x)) {
           if(csnarray.includes(n) || state.anno !== 0)
@@ -295,7 +296,7 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
         }
         else
           xpr[n] = parseExprInt(x, state);
-        if(n[0] === '@')
+        if(isAnno)
           state.anno--;
       }
     }
@@ -343,6 +344,13 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
 
 }
 
+function isSimpleAnnoValue(val) {
+  // Expressions as annotation values always have a `=` and another property.
+  // TODO: There must be at least one known expression property, otherwise
+  //       it could be `type: 'unchecked'`.
+  return !val?.['='] || Object.keys(val) < 2;
+}
+
 module.exports = {
   parseExpr,
 };

package/lib/transform/transformUtilsNew.js

@@ -12,7 +12,6 @@ const { cloneCsnNonDict, cloneCsnDictionary, getUtils } = require('../model/csnU
 const { typeParameters, isBuiltinType } = require('../compiler/builtins');
 const { ModelError, CompilerAssertion} = require('../base/error');
 const { forEach } = require('../utils/objectUtils');
-const { pathName } = require('../compiler/utils');
 
 const RestrictedOperators = ['<', '>', '>=', '<='];
 const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
@@ -321,9 +320,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
    */
   function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap()) {
     // Refs of length 1 cannot contain steps - no need to check
-    if (ref.length < 2) {
-      return ref;
-    } else if(scope === '$self' && ref.length === 2) {
+    if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
       return ref;
     }
 
@@ -1136,7 +1133,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
           const rhsIsVal = (rhs === 'null' /*|| rhs.val !== undefined*/);
 
           // lhs & rhs must be expandable types (structures or managed associations)
-          // if ever lhs should be alowed to be a value uncomment this
+          // if ever lhs should be allowed to be a value uncomment this
           if(!(lhsIsVal /*&& rhsIsVal*/) &&
              !(isDollarSelfOrProjectionOperand(lhs) || isDollarSelfOrProjectionOperand(rhs)) &&
              RelationalOperators.includes(op) &&
@@ -1162,26 +1159,41 @@ function getTransformers(model, options, pathDelimiter = '_') {
             const xrefvalues = Object.values(xref);
             let cont = true;
 
+            const prefix = (lhs, op, rhs) => {
+              return `${lhsIsVal ? lhs.val : lhs.ref.join('.')} ${op} ${rhsIsVal ? rhs : rhs.ref.join('.')}`
+            }
             if(op === 'like' && xrefvalues.reduce((a, v) => {
               return (v.lhs && v.rhs) ? a + 1: a;
             }, 0) === 0) {
               // error if intersection of paths is zero
-              error(null, location, { lhs: pathName(lhs.ref), op, rhs: pathName(rhs.ref) },
-                'Expected compatible types for $(LHS) $(OP) $(RHS)');
+              error(null, location,
+                {
+                  prefix: prefix(lhs, op, rhs)
+                },
+                'Expected compatible types for $(PREFIX)');
               cont = false;
             }
 
             cont && xrefkeys.forEach(xn => {
               const x = xref[xn];
-              const prefix = `${pathName(lhs.ref)} ${op} ${pathName(rhs.ref)}`;
               // do the paths match?
               if(op !== 'like' && !(x.lhs && x.rhs)) {
                 if(xn.length) {
-                  error(null, location, { prefix, name: xn, alias: pathName((x.lhs ? rhs : lhs).ref) },
+                  error(null, location,
+                    {
+                      prefix: prefix(lhs, op, rhs),
+                      name: xn,
+                      alias: (x.lhs ? rhs : lhs).ref.join('.')
+                    },
                     '$(PREFIX): Sub path $(NAME) not found in $(ALIAS)');
                 }
                 else {
-                  error(null, location, { prefix, name: pathName((x.lhs ? lhs : rhs).ref), alias: pathName((x.lhs ? rhs : lhs).ref) },
+                  error(null, location, 
+                    {
+                      prefix: prefix(lhs, op, rhs), 
+                      name: (x.lhs ? lhs : rhs).ref.join('.'),
+                      alias: (x.lhs ? rhs : lhs).ref.join('.')
+                    },
                     '$(PREFIX): Path $(NAME) does not match $(ALIAS)');
                 }
                 cont = false;
@@ -1189,23 +1201,38 @@ function getTransformers(model, options, pathDelimiter = '_') {
               // lhs && rhs are present, consistency checks that affect both ends
               else {
                 // is lhs scalar?
+                // eslint-disable-next-line sonarjs/no-gratuitous-expressions
                 if(!lhsIsVal && x.lhs && !isScalarOrNoType(x.lhs._art)) {
-                  error(null, location, { prefix, name: `${pathName(x.lhs.ref)}${(xn.length ? '.' + xn : '')}` },
+                  error(null, location,
+                    {
+                      prefix: prefix(lhs, op, rhs),
+                      name: `${x.lhs.ref.join('.')}${(xn.length ? '.' + xn : '')}`
+                    },
                     '$(PREFIX): Path $(NAME) must end on a scalar type')
                   cont = false;
                 }
                 // is rhs scalar?
                 if(!rhsIsVal && x.rhs && !isScalarOrNoType(x.rhs._art)) {
-                  error(null, location, { prefix, name: `${pathName(x.rhs.ref)}${(xn.length ? '.' + xn : '')}` },
+                  error(null, location,
+                    {
+                      prefix: prefix(lhs, op, rhs),
+                      name: `${x.rhs.ref.join('.')}${(xn.length ? '.' + xn : '')}`
+                    },
                     '$(PREFIX): Path $(NAME) must end on a scalar type');
                   cont = false;
                 }
                 // info about type incompatibility if no other errors occurred
+                // eslint-disable-next-line sonarjs/no-gratuitous-expressions
                 if(!(lhsIsVal || rhsIsVal) && x.lhs && x.rhs && xn && cont) {
                   const lhst = getType(x.lhs._art);
                   const rhst = getType(x.rhs._art);
                   if(lhst !== rhst) {
-                    info(null, location, { prefix, name: xn },'$(PREFIX): Types for sub path $(NAME) don\'t match');
+                    info(null, location,
+                      {
+                        prefix: prefix(lhs, op, rhs),
+                        name: xn
+                      },
+                      '$(PREFIX): Types for sub path $(NAME) don\'t match');
                   }
                 }
               }
@@ -1215,6 +1242,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
               return expr;
 
             // if lhs and rhs are refs set operator from 'like' to '='
+            // eslint-disable-next-line sonarjs/no-gratuitous-expressions
             if(op === 'like' && !(lhsIsVal || rhsIsVal)) {
               op = '=';
             }
@@ -1419,7 +1447,7 @@ function rewriteBuiltinTypeRef(csn) {
   const special$self = !csn?.definitions?.$self && '$self';
   applyTransformations(csn, {
     type: (parent, _prop, type) => {
-      if(type.ref && (
+      if(type?.ref && (
         isBuiltinType(type.ref[0]) ||
         type.ref[0] === special$self)
       ) {