@sap/cds-compiler 3.4.4 → 3.5.0

package/lib/transform/draft/db.js

@@ -18,7 +18,7 @@ const booleanBuiltin = 'cds.Boolean';
  * @param {string} pathDelimiter
  * @param {object} messageFunctions
  */
-function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
+function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   const draftSuffix = '.drafts';
   // All services of the model - needed for drafts
   const allServices = getServiceNames(csn);
@@ -38,7 +38,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
    */
-  function generateDraft(artifact, artifactName) {
+  function generateDraft( artifact, artifactName ) {
     if ((artifact.kind === 'entity') &&
         hasAnnotationValue(artifact, draftAnnotation) &&
         isPartOfService(artifactName)) {
@@ -69,7 +69,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {CSN.Artifact} rootArtifact root artifact where composition traversal started.
    * @param {object} draftNodes Dictionary of artifacts
    */
-  function collectDraftNodesInto(artifact, artifactName, rootArtifact, draftNodes) {
+  function collectDraftNodesInto( artifact, artifactName, rootArtifact, draftNodes ) {
     // Collect the artifact itself
     draftNodes[artifactName] = artifact;
     // Follow all composition targets in elements of 'artifact'
@@ -108,7 +108,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {string} artifactName
    * @param {string} draftRootName
    */
-  function generateDraftForHana(artifact, artifactName, draftRootName) {
+  function generateDraftForHana( artifact, artifactName, draftRootName ) {
     // Sanity check
     if (!isPartOfService(artifactName))
       throw new ModelError(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
@@ -234,7 +234,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
      * @param {CSN.Association} association Assoc to check
      * @returns {object}
      */
-    function getDraftUUIDKey(association) {
+    function getDraftUUIDKey( association ) {
       if (association.keys) {
         const filtered = association.keys.filter(o => (o.ref && !o.as && o.ref.length === 1 && o.ref[0] === 'DraftUUID') || (o.as && o.as === 'DraftUUID'));
         if (filtered.length === 1)
@@ -253,7 +253,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
      * @param {object} obj Any object with at least "ref"
      * @returns {string}
      */
-    function getNameForRef(obj) {
+    function getNameForRef( obj ) {
       if (obj.as)
         return obj.as;
 
@@ -285,7 +285,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {CSN.Artifact} artifact
    * @param {CSN.Artifact[]} draftNodes
    */
-  function redirectDraftTargets(artifact, draftNodes) {
+  function redirectDraftTargets( artifact, draftNodes ) {
     for (const elemName in artifact.elements) {
       const elem = artifact.elements[elemName];
       if (elem.target) {
@@ -310,7 +310,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
      * @param {string} draftNodeName
      * @returns {object} Object with shadowTarget: definition and shadowTargetName: Name of the definition
      */
-    function getDraftShadowEntityFor(draftNode, draftNodeName) {
+    function getDraftShadowEntityFor( draftNode, draftNodeName ) {
       // Sanity check
       if (!draftNodes[draftNodeName])
         throw new ModelError(`Not a draft node: ${draftNodeName}`);
@@ -325,7 +325,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {string} artifactName Absolute name of the artifact
    * @returns {boolean}
    */
-  function isPartOfService(artifactName) {
+  function isPartOfService( artifactName ) {
     for (const serviceName of allServices) {
       if (artifactName.startsWith(`${serviceName}.`))
         return true;
@@ -340,7 +340,7 @@ function generateDrafts(csn, options, pathDelimiter, messageFunctions) {
    * @param {string} artifactName Absolute name of the artifact
    * @returns {false|string} Name of the service or false if no match is found.
    */
-  function getMatchingService(artifactName) {
+  function getMatchingService( artifactName ) {
     const matches = [];
     for (const serviceName of allServices) {
       if (artifactName.startsWith(`${serviceName}.`))

package/lib/transform/draft/odata.js

@@ -23,7 +23,7 @@ const { makeMessageFunction } = require('../../base/messages');
  * @todo should be done by the compiler - Check associations for valid foreign keys
  * @todo check if needed at all: Remove '$projection' from paths in the element's ON-condition
  */
-function generateDrafts(csn, options, services) {
+function generateDrafts( csn, options, services ) {
   const {
     createForeignKeyElement,
     createAndAddDraftAdminDataProjection, createScalarElement,
@@ -73,7 +73,7 @@ function generateDrafts(csn, options, services) {
    * @param {string} artifactName
    * @param {CSN.Artifact} rootArtifact artifact where composition traversal started
    */
-  function generateDraftForOdata(artifact, artifactName, rootArtifact) {
+  function generateDraftForOdata( artifact, artifactName, rootArtifact ) {
     // Sanity check
     // @ts-ignore
     if (!isArtifactInSomeService(artifactName, services))

package/lib/transform/forOdataNew.js

@@ -10,8 +10,8 @@ const { cloneCsnNonDict,
         getArtifactDatabaseNameOf,
         getElementDatabaseNameOf,
         isAspect,
-        isBuiltinType,
         getServiceNames,
+        forEachGeneric,
       } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
@@ -165,11 +165,11 @@ function transform4odataWithCsn(inputModel, options) {
     // Needs to happen exactly between flattenAllStructStepsInRefs and flattenElements to keep model resolvable.
     // OData doesn't resolve type chains after the first 'items'
     flattening.resolveTypeReferences(csn, options, resolved, '_',
-      { skip: [ 'action', 'aspect', 'event', 'function', 'type'], 
+      { skip: [ 'action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember, skipStandard: { items: true } });
     // No structured elements exists anymore
     flattening.flattenElements(csn, options, '_', error,
-      { skip: ['action', 'aspect', 'event', 'function', 'type'], 
+      { skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
         skipStandard: { items: true },  // don't drill further into .items
         skipDict: { actions: true } }); // don't drill further into .actions -> bound actions, action-artifacts are handled by skip
@@ -213,14 +213,14 @@ function transform4odataWithCsn(inputModel, options) {
   const skipPersNameKinds = {'service':1, 'context':1, 'namespace':1, 'annotation':1, 'action':1, 'function':1};
   forEachDefinition(csn, (def, defName) => {
     // Resolve annotation shorthands for entities, types, annotations, ...
-    renameShorthandAnnotations(def, ['definitions', defName ]);
+    renameShorthandAnnotations(def);
 
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
     if (options.sqlMapping && !(def.kind in skipPersNameKinds))
       def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana'); // hana to allow naming mode "hdbcds"
 
-    forEachMemberRecursively(def, (member, memberName, propertyName, path) => {
+    forEachMemberRecursively(def, (member, memberName, propertyName) => {
       // 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)
@@ -233,7 +233,7 @@ function transform4odataWithCsn(inputModel, options) {
       annotateCoreComputed(member);
 
       // Resolve annotation shorthands for elements, actions, action parameters
-      renameShorthandAnnotations(member, path);
+      renameShorthandAnnotations(member);
 
       // - If the association target is annotated with @cds.odata.valuelist, annotate the
       //      association with @Common.ValueList.viaAssociation
@@ -255,11 +255,15 @@ function transform4odataWithCsn(inputModel, options) {
     }
   }, { skipArtifact: isExternalServiceMember })
 
+  if(isBetaEnabled(options, 'odataTerms')) {
+    forEachGeneric(csn, 'vocabularies', renameShorthandAnnotations);
+  }
+
   // Throw exception in case of errors
   throwWithAnyError();
   cleanup();
   if (options.testMode) csn = cloneCsnNonDict(csn, options);   // sort, keep hidden properties
-  timetrace.stop();
+  timetrace.stop('OData transformation');
   return csn;
 
   // TODO: Move this to checks?
@@ -298,7 +302,7 @@ function transform4odataWithCsn(inputModel, options) {
 
   // Rename shorthand annotations within artifact or element 'node' according to a builtin
   // list.
-  function renameShorthandAnnotations(node, path) {
+  function renameShorthandAnnotations(node) {
     // FIXME: Verify this list - are they all still required? Do we need any more?
     const mappings = {
       '@label': '@Common.Label',
@@ -362,38 +366,6 @@ function transform4odataWithCsn(inputModel, options) {
           setAnnotation(node, '@Validation.Minimum', node['@assert.range'][0]);
           setAnnotation(node, '@Validation.Maximum', node['@assert.range'][1]);
         }
-        // for enums @assert.range changes into a boolean annotation
-        else if (node[name] === true) {
-          let typeDef = node;
-          if(!node.enum && node.type && !isBuiltinType(node.type))
-            typeDef = csn.definitions[node.type];
-          if(typeDef.enum) {
-            const enumValue = [];
-            for(const enumSymbol in typeDef.enum) {
-              const enumSymbolDef = typeDef.enum[enumSymbol];
-              if(enumSymbolDef.val === null)
-                info('odata-enum-value-type', path,
-                  {name: enumSymbol, value: null, anno: '@Valiation.AllowedValues' },
-                  'Value $(VALUE) for enum element $(NAME) not added to $(ANNO)');
-              else {
-                const result = { '@Core.SymbolicName': enumSymbol };
-                if (enumSymbolDef.val !== undefined)
-                  result.Value = enumSymbolDef.val;
-                else if (node.type && node.type === 'cds.String')
-                  // the symbol is used as value only for type 'cds.String'
-                  result.Value = enumSymbol;
-                // Can't rely that @description has already been renamed to @Core.Description
-                // Eval description according to precedence (doc comment must be considered already in Odata transformer
-                // as in contrast to the other doc commments as it is used to annotate the @Validation.AllowedValues)
-                const desc = enumSymbolDef['@Core.Description'] || enumSymbolDef['@description'] || enumSymbolDef.doc;
-                if (desc)
-                  result['@Core.Description'] = desc;
-                enumValue.push(result);
-              }
-            }
-            setAnnotation(node, '@Validation.AllowedValues', enumValue);
-          }
-        }
       }
     });
   }

package/lib/transform/forRelationalDB.js

@@ -4,7 +4,7 @@ const { setProp, isBetaEnabled } = require('../base/model');
 const { getUtils, cloneCsnNonDict,
         forEachMemberRecursively, forAllQueries, applyTransformationsOnNonDictionary,
         getArtifactDatabaseNameOf, getElementDatabaseNameOf, isBuiltinType, applyTransformations,
-        isAspect, walkCsnPath,
+        isAspect, walkCsnPath, isPersistedOnDatabase,
       } = require('../model/csnUtils');
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtilsNew');
@@ -29,7 +29,7 @@ const { getViewTransformer } = require('./db/views');
 const cdsPersistence = require('./db/cdsPersistence');
 const temporal = require('./db/temporal');
 const associations = require('./db/associations')
-const { ModelError } = require("../base/error");
+const { ModelError } = require('../base/error');
 
 // By default: Do not process non-entities/views
 function forEachDefinition(csn, cb) {
@@ -103,8 +103,11 @@ function forEachDefinition(csn, cb) {
 function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   // copy the model as we don't want to change the input model
   timetrace.start('HANA transformation');
+
+  timetrace.start('Clone CSN');
   /** @type {CSN.Model} */
   let csn = cloneCsnNonDict(inputModel, options);
+  timetrace.stop('Clone CSN');
 
   checkCSNVersion(csn, options);
 
@@ -130,10 +133,12 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   if (!doA2J)
     forEachDefinition(csn, handleMixinOnConditions);
 
+  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
   });
+  timetrace.stop('Validate');
 
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
   handleExists(csn, options, error);
@@ -153,9 +158,11 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
   const transformCsn = transformUtils.transformModel;
 
 
+  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}));
+  timetrace.stop('temporal');
 
   // check unique constraints - further processing is done in rewriteUniqueConstraints
   assertUnique.prepare(csn, options, error, info);
@@ -227,6 +234,8 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     cloneWithTransformations,
   } = csnUtils;
 
+  timetrace.start('Transform CSN')
+
   // (000) Rename primitive types, make UUID a String
   transformCsn(csn, {
     type: (val, node, key) => {
@@ -278,9 +287,9 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
     addLocalizationViews(csn, options);
 
   !doA2J && forEachDefinition(csn, (definition, artName, prop, path) => {
-    if (definition.query) {
+    if (definition.query && isPersistedOnDatabase(definition)) {
       // reject managed association and structure publishing for to-hdbcds.hdbcds
-      const that = { csnUtils: getUtils(csn), options, error };
+      const that = { csnUtils, options, error };
       rejectManagedAssociationsAndStructuresForHdbcdsNames.call(that, definition, path)
     }
   });
@@ -351,8 +360,6 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   throwWithAnyError();
 
-  timetrace.stop();
-
   function killProp(parent, prop){
     delete parent[prop];
   }
@@ -408,6 +415,9 @@ function transformForRelationalDBWithCsn(inputModel, options, moduleName) {
 
   redoProjections.forEach(fn => fn());
 
+  timetrace.stop('Transform CSN');
+  timetrace.stop('HANA transformation');
+
   return csn;
 
   /* ----------------------------------- Functions start here -----------------------------------------------*/

package/lib/transform/localized.js

@@ -724,8 +724,8 @@ function checkExistingLocalizationViews(csn, options, messageFunctions) {
       if (!def.query && !def.projection) {
         if (!name.endsWith('.texts')) {
           hasNonViews = true;
-          messageFunctions.error('reserved-namespace-localized', ['definitions', name], {},
-            'The namespace "localized" is reserved for localization views');
+          messageFunctions.error('reserved-namespace-localized', ['definitions', name], { name: 'localized' },
+            'The namespace $(NAME) is reserved for localization views');
         }
       } else if (!hasExistingViews) {
         hasExistingViews = true;

package/lib/transform/odata/toFinalBaseType.js

@@ -1,7 +1,8 @@
 'use strict';
 
+const { isBetaEnabled } = require('../../base/model');
 const {
-  forEachDefinition, forEachMemberRecursively,
+  forEachDefinition, forEachGeneric, forEachMemberRecursively,
   isBuiltinType, cloneCsnDictionary, cloneCsnNonDict,
 } = require('../../model/csnUtils');
 const { isArtifactInSomeService, isArtifactInService } = require('./utils');
@@ -22,32 +23,33 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     expandToFinalBaseType(def.items, defName);
     expandToFinalBaseType(def.returns, defName);
     expandToFinalBaseType(def.returns && def.returns.items, defName);
-
-    // If the definition('def' variable) is a type definition and the assigned type of this very same definition('def' variable)
-    // is structured type, e.g.:
-    //
-    // type Struct1 {
-    //    a : Integer;
-    //    b : Integer;
-    //  };
-    // type Struct2: Struct1;
-    // after compilation the csn looks like this:
-    // ...
-    // "S.Struct1": {
-    //   "kind": "type",
-    //   "elements": {
-    //     "a": { "type": "cds.Integer" },
-    //     "b": { "type": "cds.Integer" }
-    //   } },
-    // "S.Struct2": {
-    //   "kind": "type",
-    //   "type": "S.Struct1",
-    //   "elements": {
-    //     "a": { "type": "cds.Integer" },
-    //     "b": { "type": "cds.Integer" }
-    //   } } ...
-    //
-    // "S.Struct2" should looks just like "S.Struct1" => the "type": "S.Struct1" property has to be removed
+    /*
+      If the definition('def' variable) is a type definition and the assigned type of this very same definition('def' variable)
+      is structured type, e.g.:
+      
+      type Struct1 {
+        a : Integer;
+        b : Integer;
+      };
+      type Struct2: Struct1;
+      after compilation the csn looks like this:
+      ...
+      "S.Struct1": {
+        "kind": "type",
+        "elements": {
+          "a": { "type": "cds.Integer" },
+          "b": { "type": "cds.Integer" }
+        } },
+      "S.Struct2": {
+        "kind": "type",
+        "type": "S.Struct1",
+        "elements": {
+          "a": { "type": "cds.Integer" },
+          "b": { "type": "cds.Integer" }
+        } } ...
+      
+      "S.Struct2" should looks just like "S.Struct1" => the "type": "S.Struct1" property has to be removed
+    */
     if (def.kind === 'type' && def.type && !isBuiltinType(def.type) && !def.type.ref) {
       // elements are already there -> do not show the type
       delete def.type;
@@ -62,6 +64,18 @@ function expandToFinalBaseType(csn, transformers, csnUtils, services, options, i
     }
   }, { skipArtifact: isExternalServiceMember });
 
+  if(isBetaEnabled(options, 'odataTerms')) {
+    forEachGeneric(csn, 'vocabularies', (def, defName) => {
+      forEachMemberRecursively(def, (member) => {
+        expandToFinalBaseType(member, defName);
+        expandToFinalBaseType(member.items, defName);
+
+      }, ['vocabularies', defName]);
+
+      expandToFinalBaseType(def, defName);
+      expandToFinalBaseType(def.items, defName);
+    }, [], { skipArtifact: isExternalServiceMember });
+  }
   // In case we have in the model something like:
   // type Foo: array of Bar; type Bar: { qux: Integer };
   // In the type Foo we expand the first level of elements of the items like we have in CDL this:

package/lib/transform/odata/typesExposure.js

@@ -8,7 +8,7 @@
 
 const { setProp } = require('../../base/model');
 const { defNameWithoutServiceOrContextName, isArtifactInService } = require('./utils');
-const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember } = require('../../model/csnUtils');
+const { cloneCsnNonDict, isBuiltinType, forEachDefinition, forEachMember, forEachGeneric } = require('../../model/csnUtils');
 const { copyAnnotations } = require('../../model/csnUtils');
 const { isBetaEnabled } = require('../../base/model.js');
 
@@ -49,6 +49,31 @@ 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
+          def.kind = 'annotation';
+          csn.definitions[defName] = def;
+          const artificialName = `term_${defName.replace(/\./g, '_')}`;//_${paramName}`;
+          const newTypeName = getNewTypeName(undefined, undefined, artificialName, serviceName);
+          exposeTypeOf(def, false, defName, defName, serviceName, newTypeName, path.concat(['vocabularies', defName]), undefined, true);
+        }
+      }
+    });
+  }
+
   return schemas;
 
 /**
@@ -82,14 +107,14 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
    * @param {String} serviceName
    * @param {String} newTypeName
    */
-  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName) {
-    const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable(node);
+  function exposeTypeOf(node, isKey, memberName, defName, serviceName, newTypeName, path, parentName, isTermDef=false) {
+    const { isExposable, typeDef, typeName, elements, isAnonymous } = isTypeExposable();
     if (isExposable) {
       // this is the name used to register the new type in csn.definitions
       let fullQualifiedNewTypeName =
         isMultiSchema
-          ? (node.type || (node.items && node.items.type)
-              ? getTypeNameInMultiSchema(node.type|| (node.items && node.items.type), serviceName)
+          ? (node.type || (node.items?.type)
+              ? getTypeNameInMultiSchema(node.type|| (node.items?.type), serviceName)
               : getAnonymousTypeNameInMultiSchema(newTypeName, parentName || defName))
           : `${serviceName}.${newTypeName}`;
 
@@ -100,7 +125,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
           isKey = false;
         // in case this was a named type and if the openess does not match the type definition
         // expose the type as a new one not changing the original definition.
-        if((!!node['@open'] !== !!typeDef['@open']) && isBetaEnabled(options, 'odataOpenType'))
+        if(elements && (!!node['@open'] !== !!typeDef['@open']) && isBetaEnabled(options, 'odataOpenType'))
           fullQualifiedNewTypeName += node['@open'] ? '_open' : '_closed';
       }
       // check if that type is already defined
@@ -118,51 +143,62 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
         /* Expose new structured type
          * Treat items.elements as ordinary elements for now.
          */
-        newType = createNewStructType(elements);
-        // if using node enforces open/closed, set it on type
-        if(node['@open'] !== undefined)
-          newType['@open'] = node['@open']
-        if (node.$location)
-          setProp(newType, '$location', node.$location);
+        if(elements) {
+          newType = createNewStructType(elements);
+          // if using node enforces open/closed, set it on type
+          if(node['@open'] !== undefined)
+            newType['@open'] = node['@open']
+          if (node.$location)
+            setProp(newType, '$location', node.$location);
 
-        csn.definitions[fullQualifiedNewTypeName] = newType;
-        exposedTypes[fullQualifiedNewTypeName] = 1;
+          csn.definitions[fullQualifiedNewTypeName] = newType;
+          exposedTypes[fullQualifiedNewTypeName] = 1;
 
-        // Recurse into elements of 'type' (if any) and expose them as well (is needed)
-        newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
-          if (node.elements && node.elements[elemName].$location)
-            setProp(newElem, '$location', node.elements[elemName].$location);
-          defName = typeDef.kind === 'type' ? typeName : defName;
-          {
-            const { isExposable, typeDef, typeName } = exposeTypeOf(newElem, isKey, elemName, defName, serviceName,
-                           getNewTypeName(newElem, elemName, newTypeName, serviceName), path, fullQualifiedNewTypeName);
-            // 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)
-            if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
-              if(typeDef.items) {
-                newElem.items = typeDef.items;
-                delete newElem.type;
-              }
-              else if(newElem.items) {
-                newElem.items.type = typeName;
-                if(typeDef.enum)
-                  newElem.items.enum = typeDef.enum;
-              }
-              else {
-                newElem.type = typeName;
-                if(typeDef.enum)
-                  newElem.enum = typeDef.enum;
+          // Recurse into elements of 'type' (if any) and expose them as well (is needed)
+          newType.elements && Object.entries(newType.elements).forEach(([elemName, newElem]) => {
+            if (node.elements && node.elements[elemName].$location)
+              setProp(newElem, '$location', node.elements[elemName].$location);
+            defName = typeDef.kind === 'type' ? typeName : defName;
+            {
+              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)
+              if(!isExposable && isBuiltinType(typeName) && !isBuiltinType((newElem.items?.type || newElem.type))) {
+                if(typeDef.items) {
+                  newElem.items = typeDef.items;
+                  delete newElem.type;
+                }
+                else if(newElem.items) {
+                  newElem.items.type = typeName;
+                  if(typeDef.enum)
+                    newElem.items.enum = typeDef.enum;
+                }
+                else {
+                  newElem.type = typeName;
+                  if(typeDef.enum)
+                    newElem.enum = typeDef.enum;
+                }
               }
             }
+          });
+          copyAnnotations(typeDef, newType);
+          // if the origin type had items, add items to exposed type
+          if(typeDef.kind === 'type') {
+            if(typeDef.items) {
+              newType.items = { elements: newType.elements };
+              delete newType.elements;
+            }
           }
-        });
-        copyAnnotations(typeDef, newType);
-        // if the origin type had items, add items to exposed type
-        if(typeDef.kind === 'type') {
-          if(typeDef.items) {
-            newType.items = { elements: newType.elements };
-            delete newType.elements;
+        }
+        else if(isTermDef) {
+          newType = Object.create(null);
+          for(let n in typeDef) {
+            newType[n] = typeDef[n];
           }
+          newType.kind = 'type';
+          csn.definitions[fullQualifiedNewTypeName] = newType;
+          exposedTypes[fullQualifiedNewTypeName] = 1;
         }
       }
       // adjust current node to new type
@@ -188,36 +224,44 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
      *  - the elements dictionary that needs to be cloned
      *  - the typeDef, either the resolved type def or the node itself
      *  - if structured type was anonymously defined
-     * @param {object} node
      * @returns {object} { isExposable, typeDef, typeName, elements, isAnonymous }
      */
-    function isTypeExposable(node) {
+    function isTypeExposable() {
       let typeName = undefined;
       let typeDef = node;
-      let elements = (node.items && node.items.elements || node.elements)
+      let elements = (node.items?.elements || node.elements)
       // anonymous structured type
       if(elements)
         return { isExposable: true, typeDef, typeName, elements, isAnonymous: true };
       // named type, resolve the type to inspect it
-      let type = node.items && node.items.type || node.type;
+      let type = node.items?.type || node.type;
       if(type) {
         typeName = (type.ref && csnUtils.getFinalType(type)) || type;
-        typeDef = csnUtils.getFinalTypeDef(typeName);
         const rc = { isExposable: true, typeDef, typeName, isAnonymous: false };
-        if(!isBuiltinType(typeName) && !isArtifactInService(typeName, serviceName)) {
-          while(!isBuiltinType(typeName)) {
-            typeDef = csnUtils.getFinalTypeDef(typeName);
-            if(typeDef) {
-              if((rc.elements = (typeDef.items && typeDef.items.elements || typeDef.elements)) !== undefined)
-                return rc;
-              type = typeDef.items && typeDef.items.type || typeDef.type;
-              typeName = (type.ref && csnUtils.getFinalType(type)) || type;
-            }
-            else {
-              throw Error(`Please debug me: ${typeName} not found`);
+        if(!isBuiltinType(typeName)) {
+          rc.typeDef = typeDef = csnUtils.getFinalTypeDef(typeName);
+          if(!isArtifactInService(typeName, serviceName)) {
+            while(!isBuiltinType(typeName)) {
+              typeDef = csnUtils.getFinalTypeDef(typeName);
+              if(typeDef) {
+                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;
+              }
+              else {
+                throw Error(`Please debug me: ${typeName} not found`);
+              }
             }
           }
+          else {
+            rc.isExposable = false;
+            return rc;
+          }
         }
+        // else if(isTermDef && typeDef.enum) {
+        //   return rc;
+        // }
       }
       return { isExposable: false, typeDef, typeName, isAnonymous: false };
     }
@@ -308,7 +352,7 @@ function typesExposure(csn, whatsMyServiceName, requestedServiceNames, fallBackS
   */
   function getNewTypeName(element, elementName, typeNamePrefix, serviceName) {
     // for the new type name node.type has precedence over node.items.type
-    const typeName = (!element.elements && element.type || element.items && !element.items.elements && element.items.type);
+    const typeName = (!element?.elements && element?.type || !element?.items?.elements && element?.items?.type);
     return typeName
         ? `${isMultiSchema
               ? typeName.split('.').pop() // use leaf element