@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/transform/db/transformExists.js

@@ -616,10 +616,10 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
       else if (typeof xpr.$env === 'number') {
         if (xpr.$scope === 'mixin')
           return '';
-        return error(null, xpr.$path, '$env with number is not handled yet - please report this error!');
+        return error(null, xpr.$path, '$env with number is not handled yet - report this error!');
       }
 
-      return error(null, xpr.$path, 'Boolean $env is not handled yet - please report this error!');
+      return error(null, xpr.$path, 'Boolean $env is not handled yet - report this error!');
     }
     else if (xpr.ref) {
       throw new ModelError('Missing $env and missing leading artifact ref - throwing to trigger recompilation!');

package/lib/transform/db/views.js

@@ -62,10 +62,9 @@ function usesMixinAssociation( query, association, associationName ) {
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {{error: Function, info: Function}} messageFunctions
- * @param {Function} transformCommon For the time being: Pass from outside
  * @returns {(query: CSN.Query, artifact: CSN.Artifact, artName: string, path: CSN.Path) => void} Transformer function for views
  */
-function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
+function getViewTransformer( csn, options, messageFunctions ) {
   const csnUtils = getUtils(csn);
   const {
     get$combined, isAssocOrComposition,
@@ -237,8 +236,6 @@ function getViewTransformer( csn, options, messageFunctions, transformCommon ) {
         // Copy the association element to the MIXIN clause under its alias name
         // Needs to be a deep copy, as we transform the on-condition
         const mixinElem = cloneCsnNonDict(elem, options);
-        // Perform common transformations on the newly generated MIXIN element (won't be reached otherwise)
-        transformCommon(mixinElem, mixinElemName);
 
         if (query.SELECT && !query.SELECT.mixin)
           query.SELECT.mixin = Object.create(null);

package/lib/transform/effective/annotations.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const { CompilerAssertion } = require('../../base/error');
+
+const directMappings = {
+  '@Common.IsDayOfCalendarMonth': replace('@Semantics.calendar.dayOfMonth'),
+  '@Common.IsDayOfCalendarYear': replace('@Semantics.calendar.dayOfYear'),
+  '@Common.IsCalendarWeek': replace('@Semantics.calendar.week'),
+  '@Common.IsCalendarMonth': replace('@Semantics.calendar.month'),
+  '@Common.IsCalendarQuarter': replace('@Semantics.calendar.quarter'),
+  '@Common.IsCalendarHalfyear': replace('@Semantics.calendar.halfyear'),
+  '@Common.IsCalendarYear': replace('@Semantics.calendar.year'),
+  '@Common.IsCalendarYearWeek': replace('@Semantics.calendar.yearWeek'),
+  '@Common.IsCalendarYearMonth': replace('@Semantics.calendar.yearMonth'),
+  '@Common.IsCalendarYearQuarter': replace('@Semantics.calendar.yearQuarter'),
+  '@Common.IsCalendarYearHalfyear': replace('@Semantics.calendar.yearHalfyear'),
+  '@Common.IsCalendarDate': replace('@Semantics.date'),
+  '@Common.IsFiscalYearVariant': replace('@Semantics.yearVariant'),
+  '@Common.IsFiscalPeriod': replace('@Semantics.period'),
+  '@Common.IsFiscalYear': replace('@Semantics.year'),
+  '@Common.IsFiscalYearPeriod': replace('@Semantics.yearPeriod'),
+  '@Common.IsFiscalQuarter': replace('@Semantics.quarter'),
+  '@Common.IsFiscalYearQuarter': replace('@Semantics.yearQuarter'),
+  '@Common.IsFiscalWeek': replace('@Semantics.week'),
+  '@Common.IsFiscalYearWeek': replace('@Semantics.yearWeek'),
+  '@Common.IsDayOfFiscalYear': replace('@Semantics.dayOfYear'),
+  '@Measures.ISOCurrency': (csn, artifact, element, oldAnno) => {
+    const { targetElement } = getAnnoRefTarget(csn, artifact, element[oldAnno]);
+    if (refPointsToThisArtifact(csn, artifact, element, oldAnno)) {
+      replace('@Semantics.amount.currencyCode')(csn, artifact, element, oldAnno);
+      if (targetElement && targetElement['@Semantics.currencyCode'] === undefined)
+        targetElement['@Semantics.currencyCode'] = true;
+    }
+  },
+  '@Measures.Unit': (csn, artifact, element, oldAnno) => {
+    const { targetElement } = getAnnoRefTarget(csn, artifact, element[oldAnno]);
+    if (refPointsToThisArtifact(csn, artifact, element, oldAnno)) {
+      replace('@Semantics.quantity.unitOfMeasure')(csn, artifact, element, oldAnno);
+      if (targetElement && targetElement['@Semantics.unitOfMeasure'] === undefined)
+        targetElement['@Semantics.unitOfMeasure'] = true;
+    }
+  },
+  '@UI.IsImageURL': replace('@Semantics.imageUrl'),
+  '@Common.ValueList.CollectionPath': (csn, artifact, element) => {
+    if (!element.target && element['@Consumption.valueHelpDefinition'] === undefined) {
+      if (element['@Common.ValueList.Parameters'] && Array.isArray(element['@Common.ValueList.Parameters'])) {
+        const InOutParameters = element['@Common.ValueList.Parameters'].filter(param => param.$Type === 'Common.ValueListParameterInOut');
+
+        if (InOutParameters.length === 1) {
+          element['@Consumption.valueHelpDefinition'] = [ {
+            name: element['@Common.ValueList.CollectionPath'],
+          } ];
+
+          delete element['@Common.ValueList.CollectionPath'];
+          delete element['@Common.ValueList.Label'];
+
+          element['@Consumption.valueHelpDefinition'][0].element = element['@Common.ValueList.Parameters'][0].ValueListProperty;
+          delete element['@Common.ValueList.Parameters'];
+        }
+      }
+    }
+  },
+  '@Common.TextFor': replace('@Semantics.text', true),
+  '@Common.IsLanguageIdentifier': replaceIf('@Semantics.language', true, (csn, artifact, element, anno) => !!element[anno]),
+  // We need to set two different annos here, depending on the value -> need a custom replacer
+  '@Common.Text': (csn, artifact, element, oldAnno) => {
+    const { targetArtifact, targetElement } = getAnnoRefTarget(csn, artifact, element[oldAnno]);
+    if (targetArtifact === artifact && !element['@ObjectModel.text.element'] && !targetElement['@Semantics.text']) {
+      element['@ObjectModel.text.element'] = element[oldAnno];
+      if (targetElement['@Semantics.text'] === undefined)
+        targetElement['@Semantics.text'] = true;
+      delete element['@Common.Text'];
+    }
+    else if (targetArtifact && targetElement && !element['@ObjectModel.text.association'] && !targetElement['@Semantics.text']) {
+      element['@ObjectModel.text.association'] = element[oldAnno];
+      if (targetElement['@Semantics.text'] === undefined)
+        targetElement['@Semantics.text'] = true;
+      delete element['@Common.Text'];
+    }
+  },
+};
+
+/**
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Artifact} artifact
+ * @param {CSN.Element} element
+ * @param {object} anno
+ * @returns {boolean}
+ */
+function refPointsToThisArtifact( csn, artifact, element, anno ) {
+  const { targetArtifact } = getAnnoRefTarget(csn, artifact, element[anno]);
+  return targetArtifact && targetArtifact === artifact;
+}
+
+/**
+ * Walk the possible annotation ref and return the artifact and element it points to
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Artifact} startArtifact
+ * @param {object} annoValue
+ * @returns {object}
+ */
+function getAnnoRefTarget( csn, startArtifact, annoValue ) {
+  if (!annoValue || !annoValue['='])
+    return { targetArtifact: undefined, targetElement: undefined };
+
+  const steps = annoValue['='].split('.');
+  let base = startArtifact;
+  let element;
+  for (const step of steps) {
+    if (!base.elements)
+      return { targetArtifact: undefined, targetElement: undefined };
+    element = base.elements[step];
+    if (!element)
+      return { targetArtifact: undefined, targetElement: undefined };
+    if (element.target)
+      base = csn.definitions[element.target];
+  }
+
+  return { targetArtifact: base, targetElement: element };
+}
+
+/**
+ * Get the function to replace oldAnno with newAnno on carrier.
+ *
+ * - If available, use "replacement" as value.
+ * - Only do replacement if "condition" returns true
+ * - Possibly set additional annotations via "additional"
+ * @param {string} newAnno
+ * @param {any} replacement
+ * @param {Function} [condition]
+ * @param {Function} [additional]
+ * @returns {Function}
+ */
+function replace( newAnno, replacement, condition = () => true, additional = () => true ) {
+  return function replaceAnnotationPrefix(csn, artifact, carrier, oldAnno) {
+    if (carrier[newAnno] === undefined && condition(csn, artifact, carrier, oldAnno, newAnno)) {
+      carrier[newAnno] = replacement || carrier[oldAnno];
+      additional(carrier, oldAnno, newAnno);
+      delete carrier[oldAnno];
+    }
+  };
+}
+
+/**
+ * Get the function to replace oldAnno with newAnno on carrier.
+ *
+ * - If available, use "replacement" as value.
+ * - Only do replacement if "condition" returns true
+ *
+ * @param {string} newAnno
+ * @param {any} replacement
+ * @param {Function} condition
+ * @returns {Function}
+ */
+function replaceIf( newAnno, replacement, condition ) {
+  return replace( newAnno, replacement, condition );
+}
+
+/**
+ *
+ * @param {CSN.Model} csn
+ * @returns {object} Transfomer object for applyTransformations
+ */
+function remapODataAnnotations( csn ) {
+  /**
+   *
+   * @param {CSN.Artifact} artifact
+   * @param {CSN.Element} element Element to process
+   */
+  function remapAnnotationsOnElement( artifact, element ) {
+    if (element.elements && !element.$ignore) // We expect to only be called on flattened CSN - error if we encounter .elements!
+      throw new CompilerAssertion(`Expected a flat model. Found element with subelements: ${JSON.stringify(element)}`);
+    for (const prop in element) {
+      if (directMappings[prop])
+        directMappings[prop](csn, artifact, element, prop);
+    }
+  }
+
+  return {
+    elements: (parent, prop, elements, path) => {
+      const artifact = csn.definitions[path[1]];
+      if (artifact?.kind === 'entity') {
+        for (const elementName in elements)
+          remapAnnotationsOnElement(artifact, elements[elementName]);
+      }
+    },
+  };
+}
+
+module.exports = {
+  remapODataAnnotations,
+};

package/lib/transform/effective/main.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const { isBetaEnabled } = require('../../base/model');
-const { CompilerAssertion } = require('../../base/error');
-const { getUtils, isAspect } = require('../../model/csnUtils');
+const {
+  getUtils, isAspect, mergeTransformers, applyTransformations,
+} = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const flattening = require('../db/flattening');
 const types = require('./types');
@@ -14,6 +14,7 @@ const associations = require('./associations');
 const generateDrafts = require('../draft/db');
 const handleExists = require('../db/transformExists');
 const misc = require('./misc');
+const annotations = require('./annotations');
 const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('../db/rewriteCalculatedElements');
 const { cloneFullCsn } = require('../../model/cloneCsn');
 
@@ -30,15 +31,12 @@ const { cloneFullCsn } = require('../../model/cloneCsn');
  * @returns {CSN.Model}
  */
 function effectiveCsn( model, options, messageFunctions ) {
-  if (!isBetaEnabled(options, 'effectiveCsn'))
-    throw new CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
-
   const csn = cloneFullCsn(model, options);
   delete csn.vocabularies; // must not be set for effective CSN
   messageFunctions.setModel(csn);
 
   const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, messageFunctions, '_');
-  queries.projectionToSELECTAndAddColumns(csn);
+  const redoProjections = queries.projectionToSELECTAndAddColumns(csn);
 
   let csnUtils = getUtils(csn, 'init-all');
 
@@ -63,7 +61,7 @@ function effectiveCsn( model, options, messageFunctions ) {
   // Expand a structured thing in: keys, columns, order by, group by
   expansion.expandStructureReferences(csn, options, '_', messageFunctions, csnUtils);
 
-  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils);
+  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils, options);
 
   // Remove properties attached by validator - they do not "grow" as the model grows.
   cleanup();
@@ -80,8 +78,11 @@ function effectiveCsn( model, options, messageFunctions ) {
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
   generateDrafts(csn, options, '_', messageFunctions);
-  misc.attachPersistenceName(csn, options, csnUtils);
-  misc.removeDefinitionsAndProperties(csn);
+  const transformers = mergeTransformers([ misc.attachPersistenceName(csn, options, csnUtils), options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);
+  applyTransformations(csn, transformers, [], { skipIgnore: false });
+
+  if (!options.resolveProjections)
+    redoProjections.forEach(fn => fn());
 
   messageFunctions.throwWithError();
 

package/lib/transform/effective/misc.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  forEachDefinition, forEachMemberRecursively, getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
+  getArtifactDatabaseNameOf, getElementDatabaseNameOf,
 } = require('../../model/csnUtils');
 /**
  * Attach @cds.persistence.name to all artifacts and "things".
@@ -9,15 +9,34 @@ const {
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {object} csnUtils
+ * @returns {object}
  */
 function attachPersistenceName( csn, options, csnUtils ) {
   const { addStringAnnotationTo } = csnUtils;
 
-  forEachDefinition(csn, (artifact, artifactName) => {
-    addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
+  /**
+   *
+   * @param {object} parent
+   * @param {string} prop
+   * @param {object} dict
+   * @param {CSN.Path} path
+   */
+  function addToEachMember( parent, prop, dict, path ) {
+    const artifact = csn.definitions[path[1]];
+    if (artifact?.kind === 'entity') {
+      for (const memberName in dict)
+        addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), dict[memberName]);
+    }
+  }
 
-    forEachMemberRecursively(artifact, (member, memberName) => addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member), [ 'definitions', artifactName ]);
-  });
+  return {
+    kind: (parent, prop, kind, path) => {
+      if (kind === 'entity')
+        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(path[1], options.sqlMapping, csn, options.sqlDialect), parent);
+    },
+    elements: addToEachMember,
+    params: addToEachMember,
+  };
 }
 
 /**
@@ -39,20 +58,29 @@ function killProp( parent, prop ) {
  * - includes
  * - localized
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
+ * @returns {object}
  * @todo Callback-like architecture and merge with persistence name?
  */
-function _removeDefinitionsAndProperties( csn ) {
-  const killers = {
+function _removeDefinitionsAndProperties( csn, options ) {
+  const transformers = {
     $ignore: (a, b, c, path, parentParent) => {
       const tail = path[path.length - 1];
       delete parentParent[tail];
     },
     kind: (artifact, a, b, path) => {
-      if (artifact.kind === 'aspect' || artifact.kind === 'type')
-        delete csn.definitions[path[1]];
-
-      else if (artifact['@cds.persistence.skip'] === 'if-unused')
-        artifact['@cds.persistence.skip'] = false;
+      if (artifact.kind === 'aspect' || artifact.kind === 'type') {
+        if (artifact.elements || artifact.items || options.resolveSimpleTypes)
+          delete csn.definitions[path[1]];
+      }
+      else {
+        if (artifact.kind === 'event') {
+          delete artifact.projection;
+          delete artifact.query;
+        }
+        if (artifact['@cds.persistence.skip'] === 'if-unused')
+          artifact['@cds.persistence.skip'] = false;
+      }
     },
     // Still used in flattenStructuredElements - in db/flattening.js
     _flatElementNameWithDots: killProp,
@@ -64,13 +92,16 @@ function _removeDefinitionsAndProperties( csn ) {
     // Set when we remove .key from temporal things, used in localized.js
     $key: killProp,
     includes: killProp,
-    localized: killProp,
     enum: killProp,
     keys: killProp,
     excluding: killProp, // * is resolved, so has no effect anymore
+    targetAspect: killProp,
   };
 
-  applyTransformations(csn, killers, [], { skipIgnore: false });
+  if (!options.keepLocalized)
+    transformers.localized = killProp;
+
+  return transformers;
 }
 
 

package/lib/transform/effective/types.js

@@ -17,10 +17,11 @@ const { cloneCsnDict, cloneCsnNonDict } = require('../../model/cloneCsn');
  * @todo What about annotations on the type?
  * @param {CSN.Model} csn will be transformed
  * @param {object} csnUtils
+ * @param {CSN.Options} options
  * @returns {Function} Callback to resolve things (actions and their returns) later - as for them, $self would lead to unresolvable constructs at this point
  * so we can call this callback after flattening is done - then we can safely resolve their types.
  */
-function resolveTypes( csn, csnUtils ) {
+function resolveTypes( csn, csnUtils, options ) {
   const { getFinalTypeInfo } = csnUtils;
   const later = [];
   applyTransformations(csn, {
@@ -51,7 +52,7 @@ function resolveTypes( csn, csnUtils ) {
    *
    * Drill down into .elements and .items
    *
-   * @param {object} parent Object with a .type propertie
+   * @param {object} parent Object with a .type property
    */
   function resolveType( parent ) {
     // TODO: I assume there can be cases with a type ref but still having .elements already? Subelement anno?
@@ -67,7 +68,7 @@ function resolveTypes( csn, csnUtils ) {
         parent.items = cloneCsnNonDict(final.items);
       delete parent.type;
     }
-    else if (final?.type) {
+    else if (final?.type && (options.resolveSimpleTypes || parent.type.ref?.length > 1)) {
       forEachKey(final, (key) => { // copy `type` + properties (default, etc.)
         if (parent[key] === undefined || key === 'type')
           parent[key] = final[key];

package/lib/transform/forOdata.js

@@ -73,7 +73,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   timetrace.start('OData transformation');
 
   // copy the model as we don't want to change the input model
-  let csn = cloneFullCsn(inputModel, options);
+  const csn = cloneFullCsn(inputModel, options);
   messageFunctions.setModel(csn);
 
   const { message, error, warning, info, throwWithAnyError } = messageFunctions;
@@ -119,6 +119,11 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
 
+  // - Generate artificial draft fields on a structured CSN if requested, flattening and struct
+  //   expansion do their magic including foreign key generation and annotation propagation.
+  //   Tenantenizer has to decorate the DraftAdministrativeData, so draft decoration must be done before.
+  generateDrafts(csn, options, services, messageFunctions);
+
   if (options.tenantDiscriminator)
     addTenantFields(csn, options);
 
@@ -171,9 +176,6 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   // rendering which may has to publish external definitions
   expandToFinalBaseType(csn, transformers, csnUtils, services, options, error);
 
-  // - Generate artificial draft fields on a structured CSN if requested, flattening and struct
-  //   expansion do their magic including foreign key generation and annotation propagation.
-  generateDrafts(csn, options, services, messageFunctions);
 
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
@@ -182,15 +184,19 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
   if (!structuredOData) {
-    expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, csnUtils, { skipArtifact: isExternalServiceMember });
+    expansion.expandStructureReferences(csn, options, '_',
+      { error, info, throwWithAnyError }, csnUtils,
+      { skipArtifact: isExternalServiceMember });
     const resolved = new WeakMap();
 
     const { inspectRef, effectiveType } = csnRefs(csn);
-    const { adaptRefs, transformer: refFlattener } = flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
-
-    flattening.allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternalServiceMember, error, csnUtils, options);
+    const { adaptRefs, transformer: refFlattener } =
+      flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
 
+    flattening.allInOneFlattening(csn, refFlattener, adaptRefs,
+        inspectRef, isExternalServiceMember, error, csnUtils, options);
     flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs,
+        inspectRef, effectiveType, csnUtils, error, options,
       { //skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
       });
@@ -199,20 +205,30 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     // rewritten path expressions
     forEachDefinition(csn, (def) => {
       ['elements', 'params'].forEach(dictName => {
-        if(def[`$${dictName}`])
-          def[dictName] = def[`$${dictName}`];
+        if(def[`$flat${dictName}`])
+          def[dictName] = def[`$flat${dictName}`];
       })
       if(def.$flatAnnotations) {
         Object.entries(def.$flatAnnotations).forEach(([an, av]) => {
           def[an] = av; 
         })
       }
+      if(def.actions) {
+        Object.values(def.actions).forEach((action) => {
+          if(action.$flatAnnotations) {
+            Object.entries(action.$flatAnnotations).forEach(([an, av]) => {
+              action[an] = av;
+            });
+          }
+        });
+      }
     });
   }
 
   // TODO: add the generated foreign keys to the columns when we are in a view
   // see db/views.js::addForeignKeysToColumns
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_',
+    !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
@@ -251,7 +267,8 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     // 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"
+       // hana to allow naming mode "hdbcds"
+      def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana');
 
     forEachMemberRecursively(def, (member, memberName, propertyName) => {
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested