@sap/cds-compiler 3.5.4 → 3.6.0

package/lib/transform/forOdataNew.js

@@ -70,6 +70,7 @@ module.exports = { transform4odataWithCsn };
 
 function transform4odataWithCsn(inputModel, options) {
   timetrace.start('OData transformation');
+
   // copy the model as we don't want to change the input model
   let csn = cloneCsnNonDict(inputModel, options);
 
@@ -125,6 +126,9 @@ function transform4odataWithCsn(inputModel, options) {
 
   addLocalizationViews(csn, options, { acceptLocalizedView, ignoreUnknownExtensions: true });
 
+  // replace all type refs to builtin types with direct type
+  transformUtils.rewriteBuiltinTypeRef(csn);
+
   const cleanup = validate.forOdata(csn, {
     message, error, warning, info, inspectRef, effectiveType, getFinalBaseTypeWithProps, artifactRef, csn, options, csnUtils, services, isAspect, isExternalServiceMember
   });
@@ -148,7 +152,12 @@ function transform4odataWithCsn(inputModel, options) {
     { skipArtifact: isExternalServiceMember }
   );
 
-  expandToFinalBaseType(csn, transformers, csnUtils, services, options, isExternalServiceMember);
+  // All type refs must be resolved, including external APIs.
+  // OData has no 'type of' so 'real' imported OData APIs marked @cds.external are safe.
+  // If in the future 'other' APIs that might support type refs are imported, these refs must be
+  // resolved here, as this is the OData transformation and sets the foundation for subsequent EDM
+  // rendering which may has to publish external definitions
+  expandToFinalBaseType(csn, transformers, csnUtils, services, options);
 
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
@@ -157,7 +166,7 @@ function transform4odataWithCsn(inputModel, options) {
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
   if (!structuredOData) {
-    expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, { skipArtifact: isExternalServiceMember });
+    expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, csnUtils, { skipArtifact: isExternalServiceMember });
     const resolved = new WeakMap();
     // No refs with struct-steps exist anymore
     flattening.flattenAllStructStepsInRefs(csn, options, resolved, '_', { skipArtifact: isExternalServiceMember });
@@ -177,13 +186,13 @@ function transform4odataWithCsn(inputModel, options) {
 
   // TODO: add the generated foreign keys to the columns when we are in a view
   // see db/views.js::addForeignKeysToColumns
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, '_', !structuredOData, { skipArtifact: isExternalServiceMember });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
   // since then the foreign keys of the managed assocs are part of the elements
   if(!structuredOData)
-    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, '_'));
+    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, '_'));
 
   // structure flattener reports errors, further processing is not safe -> throw exception in case of errors
   throwWithAnyError();
@@ -221,6 +230,8 @@ function transform4odataWithCsn(inputModel, options) {
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana'); // hana to allow naming mode "hdbcds"
 
     forEachMemberRecursively(def, (member, memberName, propertyName) => {
+      if (memberName === '' && propertyName === 'params')
+        return; // ignore "returns" type
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested
       // Only these are actually required and don't annotate virtual elements in entities or types
       // as they have no DB representation (although in views)

package/lib/transform/forRelationalDB.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { setProp, isBetaEnabled } = require('../base/model');
-const { getUtils, cloneCsnNonDict,
+const { cloneCsnNonDict,
         forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
         isAspect, walkCsnPath, isPersistedOnDatabase,
@@ -113,11 +113,26 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   const pathDelimiter = (options.sqlMapping === 'hdbcds') ? '.' : '_';
 
+  let csnUtils;
   let message, error, warning, info; // message functions
   /** @type {() => void} */
   let throwWithAnyError;
-  let artifactRef, inspectRef, effectiveType, get$combined,
-    addDefaultTypeFacets, expandStructsInExpression; // transformUtils
+  // csnUtils
+  let artifactRef,
+    inspectRef,
+    effectiveType,
+    get$combined,
+    getCsnDef,
+    isAssocOrComposition,
+    addStringAnnotationTo,
+    cloneWithTransformations;
+  // transformUtils
+  let addDefaultTypeFacets,
+    expandStructsInExpression,
+    flattenStructuredElement,
+    flattenStructStepsInRef,
+    isAssociationOperand,
+    isDollarSelfOrProjectionOperand;
 
   bindCsnReference();
 
@@ -133,10 +148,13 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   if (!doA2J)
     forEachDefinition(csn, handleMixinOnConditions);
 
+  // replace all type refs to builtin types with direct type
+  transformUtils.rewriteBuiltinTypeRef(csn);
+
   timetrace.start('Validate');
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
-    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils: getUtils(csn), csn, options, isAspect
+    message, error, warning, info, inspectRef, effectiveType, artifactRef, csnUtils, csn, options, isAspect
   });
   timetrace.stop('Validate');
 
@@ -161,7 +179,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   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}));
+  forEachDefinition(csn, temporal.getViewDecorator(csn, {info}, csnUtils));
   timetrace.stop('temporal');
 
   // check unique constraints - further processing is done in rewriteUniqueConstraints
@@ -169,7 +187,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   if(doA2J) {
     // Expand a structured thing in: keys, columns, order by, group by
-    expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithAnyError});
+    expansion.expandStructureReferences(csn, options, pathDelimiter, {error, info, throwWithAnyError}, csnUtils);
     bindCsnReference();
   }
 
@@ -220,20 +238,6 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     }
   });
 
-  const {
-    flattenStructuredElement,
-    flattenStructStepsInRef,
-    isAssociationOperand, isDollarSelfOrProjectionOperand,
-    csnUtils,
-  } = transformUtils.getTransformers(csn, options, pathDelimiter);
-
-  const {
-    getCsnDef,
-    isAssocOrComposition,
-    addStringAnnotationTo,
-    cloneWithTransformations,
-  } = csnUtils;
-
   timetrace.start('Transform CSN')
 
   // (000) Rename primitive types, make UUID a String
@@ -260,11 +264,11 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   forEachDefinition(csn, temporal.getAnnotationHandler(csn, options, pathDelimiter, {error}));
 
   // eliminate the doA2J in the functions 'handleManagedAssociationFKs' and 'createForeignKeyElements'
-  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
+  doA2J && flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, pathDelimiter, true, csnUtils, { skipDict: { actions: true }, allowArtifact: artifact => (artifact.kind === 'entity') });
 
   doA2J && forEachDefinition(csn, flattenIndexes);
   // Managed associations get an on-condition - in views and entities
-  doA2J && associations.attachOnConditions(csn, pathDelimiter);
+  doA2J && associations.attachOnConditions(csn, csnUtils, pathDelimiter);
 
   // (045) Strip all query-ish properties from views and projections annotated with '@cds.persistence.table',
   // and make them entities
@@ -274,7 +278,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   // To be done after handleAssociations, since then the foreign keys of the managed assocs
   // are part of the elements
   if (doA2J)
-    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, pathDelimiter));
+    forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, pathDelimiter));
 
   // Create convenience views for localized entities/views.
   // To be done after getFKAccessFinalizer because associations are
@@ -330,7 +334,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   assertUnique.rewrite(csn, options, pathDelimiter);
 
   // Associations that point to things marked with @cds.persistence.skip are removed
-  forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, {info}));
+  forEachDefinition(csn, cdsPersistence.getAssocToSkippedIgnorer(csn, options, {info}, csnUtils));
 
   // Apply view-specific transformations
   // (160) Projections now finally become views
@@ -424,9 +428,25 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   function bindCsnReference(){
     ({ error, warning, info, message, throwWithAnyError } = makeMessageFunction(csn, options, moduleName));
-    ({ addDefaultTypeFacets, expandStructsInExpression } = transformUtils.getTransformers(csn, options, pathDelimiter));
-    // TODO: Can we use csnUtils of the call above (transformUtils.getTransformers)?
-    ({ artifactRef, inspectRef, effectiveType, get$combined } = getUtils(csn));
+
+    ({ flattenStructuredElement,
+      flattenStructStepsInRef,
+      isAssociationOperand,
+      isDollarSelfOrProjectionOperand,
+      addDefaultTypeFacets,
+      expandStructsInExpression,
+      csnUtils
+    } = transformUtils.getTransformers(csn, options, pathDelimiter));
+
+    ({ artifactRef,
+      inspectRef,
+      effectiveType,
+      get$combined,
+      getCsnDef,
+      isAssocOrComposition,
+      addStringAnnotationTo,
+      cloneWithTransformations
+    } = csnUtils);
   }
 
   function bindCsnReferenceOnly(){
@@ -445,7 +465,7 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         .filter((c) => {
           return c.ref &&  c.ref.length > 1;
         })
-        .map((usedAssoc) => {
+        .forEach((usedAssoc) => {
           const assocName = pathId(usedAssoc.ref[0]);
           const mixinAssociation = mixin[assocName];
           if(mixinAssociation){
@@ -528,6 +548,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
         addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
       forEachMemberRecursively(artifact, (member, memberName, property, path) => {
+        if (memberName === '' && property === 'params')
+          return; // ignore "returns" type
         transformCommon(member, memberName, path);
         // (240 b) Annotate elements, foreign keys, parameters etc with their DB names
         // Virtual elements in entities and types are not annotated, as they have no DB representation.
@@ -874,9 +896,9 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
       // a backlink association element from an entity, the forward link will point to the entity,
       // not to the view).
       // FIXME: This also means that corresponding key fields should be in the select list etc ...
-      if (!art.query && !art.projection && assoc.target && assoc.target != artifactName)
-        error(null, path, { name: '$self' }, 'Only an association that points back to this artifact can be compared to $(NAME)');
-
+      if (!art.query && !art.projection && assoc.target && assoc.target !== artifactName)
+        error( null, path, { id: '$self', name: artifactName, target: assoc.target },
+               'Expected association using $(ID) to point back to $(NAME) but found $(TARGET)' );
 
       // Check: The forward link <assocOp> must not contain '$self' in its own ON-condition
       if (assoc.on) {
@@ -997,14 +1019,6 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     function _check(node, nodeName, model, path) {
       if (node.type) {
         const absolute = node.type;
-        const parameters = node.parameters || [];
-        // :FIXME: Is this dead code? node.parameters is always undefined...
-        // forRelationalDB tested against the parameters of the type definition which is not available in CSN
-        for (const name in parameters) {
-          const param = parameters[name];
-          if (!node[param] && absolute !== 'cds.hana.ST_POINT' && absolute !== 'cds.hana.ST_GEOMETRY')
-            error('missing-type-parameter', path, { name: param, id: absolute, $reviewed: false });
-        }
         switch (absolute) {
           case 'cds.String':
           case 'cds.Binary':

package/lib/transform/odata/toFinalBaseType.js

@@ -9,6 +9,7 @@ const { isArtifactInSomeService, isArtifactInService } = require('./utils');
 
 function expandToFinalBaseType(csn, transformers, csnUtils, services, options, isExternalServiceMember) {
   const isV4 = options.odataVersion === 'v4';
+  const special$self = !csn?.definitions?.$self && '$self';
   forEachDefinition(csn, (def, defName) => {
     // Unravel derived type chains to final one for elements, actions, action parameters (propagating annotations)
     forEachMemberRecursively(def, (member) => {
@@ -100,109 +101,132 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     // EDMX at the moment and the reference in the OData CSN is fulfilled.
     if (node.kind === 'event') return;
 
-    // elements have precedence over type
-    if (node.type && (!isBuiltinType(node.type) && isExpandable(node, defName) || node.kind === 'type')) {
-      // 1. Get the final type of the node (resolve derived type chain)
-      const finalType = csnUtils.getFinalBaseTypeWithProps(node.type);
-      if (finalType) {
-        // The type replacement depends on whether 'node' is a definition or a member[element].
-        if (node.kind) {
-          // It is a definition and we expand to builtin type and to elements
-          // type T: S; --> Integer;
-          // type S: X; --> Integer;
-          // type X: Integer;
-          //
-          // type A: B; -> {...}
-          // type B: C; -> { ... }
-          // type C { .... };
-          if (isBuiltinType(finalType.type)) {
-            // use transformUrilsNew::toFinalBaseType for the moment,
-            // as it is collects along the chain of types
-            // attributes that need to be propagated
-            // enum, length, scale, etc.
-            transformers.toFinalBaseType(node);
-            // node.type = finalType;
-          }
-          else if (csnUtils.isStructured(finalType)) {
-            cloneElements(finalType);
+    if(node.type && !isBuiltinType(node.type)) {
+      const finalBaseType = csnUtils.getFinalBaseTypeWithProps(node.type);
+      if(!finalBaseType) {
+        /*
+          type could not be resolved, set it to null
+          Today, all type refs must be resolvable,
+          input validations checkTypeDefinitionHasType, checkElementTypeDefinitionHasType
+          guarantee this. In the future this may change.
+        */
+        node.type = null;
+      }
+      else {
+        if (isExpandable(finalBaseType) || node.kind === 'type') {
+          // 1. Get the final type of the node (resolve derived type chain)
+          if (finalBaseType.type !== special$self) {
+            // The type replacement depends on whether 'node' is a definition or a member[element].
+            if (node.kind) {
+              /*
+                It is a definition and we expand to builtin type and to elements
+                type T: S; --> Integer;
+                type S: X; --> Integer;
+                type X: Integer;
+
+                type A: B; -> {...}
+                type B: C; -> { ... }
+                type C { .... };
+              */
+              if (isBuiltinType(finalBaseType.type)) {
+                /*
+                  use transformUtilsNew::toFinalBaseType for the moment,
+                  as it is collects along the chain of types
+                  attributes that need to be propagated
+                  enum, length, scale, etc.
+                */
+                transformers.toFinalBaseType(node);
+              }
+              else if (csnUtils.isStructured(finalBaseType)) {
+                cloneElements(finalBaseType);
+              }
+              else if (node.type && node.items)
+                delete node.type;
+            }
+            else {
+              /*
+                this is a member and we expand to final base only if builtin
+                  type T: S; --> Integer;
+                  type S: X; --> Integer;
+                  type X: Integer;
+
+                  type {
+                    struct_elt: many A; ---> stays the same
+                    scalar_elt: T; ---> Integer;
+                    type_ref_elt: type of struct_elt;
+                  };
+                  type A: B; -> {...}
+                  type B: C; -> { ... }
+                  type C { .... };
+              */
+              if (isBuiltinType(finalBaseType.type)) {
+                /*
+                  use transformUtilsNew::toFinalBaseType for the moment,
+                  as it is collects along the chain of types
+                  attributes that need to be propagated
+                  enum, length, scale, etc.
+                */
+                transformers.toFinalBaseType(node);
+                // node.type = finalType;
+              }
+              else if (node.type && node.type.ref) {
+                cloneElements(finalBaseType);
+              }
+            }
           }
-          else if (node.type && node.items)
-            delete node.type;
         }
-        else {
-          // this is a member and we expand to final base only if builtin
-          //  type T: S; --> Integer;
-          //  type S: X; --> Integer;
-          //  type X: Integer;
-          //
-          //  type {
-          //    struct_elt: many A; ---> stays the same
-          //    scalar_elt: T; ---> Integer;
-          //    type_ref_elt: type of struct_elt;
-          //  };
-          //  type A: B; -> {...}
-          //  type B: C; -> { ... }
-          //  type C { .... };
-          if (isBuiltinType(finalType.type)) {
-            // use transformUtilsNew::toFinalBaseType for the moment,
-            // as it is collects along the chain of types
-            // attributes that need to be propagated
-            // enum, length, scale, etc.
-            transformers.toFinalBaseType(node);
-            // node.type = finalType;
-          }
-          else if (node.type && node.type.ref) {
-            cloneElements(finalType);
+        if (/*the resolved type is not built in*/ !isBuiltinType(node.type)) {
+          // handle array of defined via a named type
+          // example in actions: 'action act() return Primitive; type Primitive: array of String;'
+          const currService = csnUtils.getServiceName(defName);
+          const isArrayOfBuiltin = finalBaseType.items && 
+            isBuiltinType(csnUtils.getFinalBaseTypeWithProps(finalBaseType.items.type)?.type)
+          if (isArrayOfBuiltin && (!isArtifactInService(node.type, currService) || !isV4)) {
+            node.items = finalBaseType.items;
+            delete node.type;
           }
         }
       }
     }
-    if (node.type && !isBuiltinType(node.type)) {
-        // handle array of defined via a named type
-        // example in actions: 'action act() return Primitive; type Primitive: array of String;'
-      const currService = csnUtils.getServiceName(defName);
-      const finalType = csnUtils.getFinalBaseTypeWithProps(node.type);
-      const isArrayOfBuiltin = finalType?.items && isBuiltinType(csnUtils.getFinalBaseTypeWithProps(finalType.items.type)?.type)
-      if (isArrayOfBuiltin && (!isArtifactInService(node.type, currService) || !isV4)) {
-        node.items = finalType.items;
-        delete node.type;
-      }
-    }
 
-    function cloneElements(finalType) {
+    function cloneElements(finalBaseType) {
       // cloneCsn only works correctly if we start "from the top"
       let clone;
       // do the clone only if really needed
-      if((finalType.items && !node.items) ||
-         (finalType.elements && !node.elements))
-        clone = cloneCsnNonDict({ definitions: { 'TypeDef': finalType } }, options);
-      if (finalType.items) {
+      if((finalBaseType.items && !node.items) ||
+         (finalBaseType.elements && !node.elements))
+        clone = cloneCsnNonDict({ definitions: { 'TypeDef': finalBaseType } }, options);
+      if (finalBaseType.items) {
         delete node.type;
         if(!node.items)
           Object.assign(node, { items: clone.definitions.TypeDef.items });
       }
-      if (finalType.elements) {
-        if(!finalType.items)
+      if (finalBaseType.elements) {
+        if(!finalBaseType.items)
           delete node.type;
         if(!node.elements)
           Object.assign(node, { elements: clone.definitions.TypeDef.elements });
       }
     }
-  }
 
-  function isExpandable(node, defName) {
-    return !isV4 || !isUserDefinedBuiltinFromTheCurrService(node, defName);
-  }
+    /*
+      Check, if a type needs to be expanded into the service
 
-  function isUserDefinedBuiltinFromTheCurrService(node, defName) {
-    // in V4 we should use TypeDefinitions whenever possible, thus in case the final type of a field is
-    // a builtin from the service - do not expand to the final base type
-    let finalBaseType = csnUtils.getFinalBaseTypeWithProps(node.type).type;
-    // if (finalBaseType && finalBaseType.items) finalBaseType = csnUtils.getFinalBaseTypeWithProps(finalBaseType.items);
-    const currService = csnUtils.getServiceName(defName);
-    return node.type && !node.type.ref
-      && isBuiltinType(finalBaseType) && !csnUtils.isAssocOrComposition(finalBaseType)
-      && isArtifactInService(node.type, currService);
+      All types are expansion candidates except these in V4:
+      - it's a builtin
+      - it's an assoc
+      - the referred type is defined in the service
+    */
+    function isExpandable(finalBaseType) {
+        // in V4 we should use TypeDefinitions whenever possible, thus in case the final type of a field is
+        // a builtin from the service - do not expand to the final base type
+
+      const currService = csnUtils.getServiceName(defName);
+      const isBuiltin = isBuiltinType(finalBaseType.type);
+      const isAssoc = node.target;
+      const isInCurServ = isArtifactInService(node.type, currService);
+      return !isV4 || !(isBuiltin && !isAssoc && isInCurServ);
+    }
   }
 }
 

package/lib/transform/odata/typesExposure.js

@@ -9,11 +9,13 @@
 const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
 const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
-const { copyAnnotations } = require('../../model/csnUtils');
+const { copyAnnotations, getNamespace } = require('../../model/csnUtils');
 const { isBetaEnabled } = require('../../base/model.js');
+const { CompilerAssertion } = require('../../base/error');
 
 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
@@ -163,7 +165,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
               const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
                             getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName, isTermDef);
               // if the type for the newElem was not exposed it may be a scalar type def from an external service that hasn't
-              // been catched by expandToFinalBaseType() (forODataNew must not modify external imported services)
+              // been caught by expandToFinalBaseType() (forODataNew must not modify external imported services)
               if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
                 if(typeDef.items) {
                   newElem.items = typeDef.items;
@@ -214,16 +216,19 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
     }
     return { isExposable, typeDef, typeName, isAnonymous };
 
-     /**
+    /**
      * Check if the node's type can be exposed:
-     * 1) If it's an anonymous structured type (items.elements || elements)
+     * 1) If it's an anonymous, structured type (items.elements || elements)
      * 2) If it's a named type resolve to the final type definition and
      *    check if this is a structured type
+     *
      * Returns an object that indicates
-     *  - wether or not the type needs exposure
-     *  - the elements dictionary that needs to be cloned
-     *  - the typeDef, either the resolved type def or the node itself
+     *  - `isExposable`: whether the type needs exposure
+     *  - `elements`: dictionary that needs to be cloned
+     *  - `typeDef`: either the resolved type def or the node itself
+     *  - `typeName`
      *  - if structured type was anonymously defined
+     *
      * @returns {object} { isExposable, typeDef, typeName, elements, isAnonymous }
      */
     function isTypeExposable() {
@@ -236,21 +241,22 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
       // named type, resolve the type to inspect it
       let type = node.items?.type || node.type;
       if(type) {
-        typeName = (type.ref && csnUtils.getFinalType(type)) || type;
+        typeName = (type.ref && csnUtils.artifactRef(type)) || type;
         const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
-        if(!isBuiltinType(typeName)) {
-          rc.typeDef = typeDef = csnUtils.getFinalTypeDef(typeName);
+        if(!isBuiltinType(typeName) && typeName !== special$self) {
+          rc.typeDef = typeDef = csnUtils.artifactRef(typeName, typeName);
           if(!isArtifactInService(typeName, serviceName)) {
             while(!isBuiltinType(typeName)) {
-              typeDef = csnUtils.getFinalTypeDef(typeName);
-              if(typeDef) {
+              typeDef = csnUtils.artifactRef(typeName, typeName);
+              if(typeDef !== typeName) {
+                // Implementation note: For `type S: T:struct;`, elements from `T:struct` were already propagated to `S`.
                 if((isTermDef && typeDef.enum) || (rc.elements = (typeDef.items?.elements || typeDef.elements)) !== undefined)
                   return rc;
                 type = typeDef.items?.type || typeDef.type;
-                typeName = (type.ref && csnUtils.getFinalType(type)) || type;
+                typeName = (type.ref && csnUtils.artifactRef(type)) || type;
               }
               else {
-                throw Error(`Please debug me: ${typeName} not found`);
+                throw new CompilerAssertion(`Please debug me: ${typeName} not found`);
               }
             }
           }
@@ -285,11 +291,14 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         return `${newSchemaName}.${typePlainName.replace(/\./g, '_')}`;
       } else {
         const typeContext = csnUtils.getContextOfArtifact(typeName);
-        const typeNamespace = csnUtils.getNamespaceOfArtifact(typeName);
+        const typeNamespace = getNamespace(csn, typeName);
         const newSchemaName = `${serviceName}.${typeContext || typeNamespace || fallBackSchemaName}`;
         // new type name without any prefixes
-        const typePlainName = typeContext ? defNameWithoutServiceOrContextName(typeName, typeContext)
-          : typeName.replace(`${typeNamespace}.`, '');
+        const typePlainName = typeContext
+          ? defNameWithoutServiceOrContextName(typeName, typeContext)
+          : (typeNamespace
+              ? typeName.replace(typeNamespace + '.', '')
+              : typeName);
         createSchema(newSchemaName);
         // return the new type name
         return `${newSchemaName}.${typePlainName.replace(/\./g, '_')}`;

package/lib/transform/odata/utils.js

@@ -26,7 +26,7 @@ function getServiceOfArtifact(artName, services) {
  * @param {string} service Name of the service
  */
 function isArtifactInService(artName, service) {
-  return artName.startsWith(`${service}.`);
+  return typeof artName === 'string' ? artName.startsWith(`${service}.`) : false;
 }
 
 /**

package/lib/transform/parseExpr.js

@@ -39,7 +39,7 @@
  *  nary: return n-ary or binary tree
  */
 
-function parseExpr(xpr, state = { anno: 0, array: true, nary: true }) {
+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>