@sap/cds-compiler 6.1.0 → 6.3.0

package/lib/transform/db/associations.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  transformAnnotationExpression,
   applyTransformationsOnNonDictionary,
   applyTransformations,
   implicitAs,
@@ -106,18 +107,40 @@ function attachOnConditions( csn, csnUtils, pathDelimiter, iterateOptions = {},
 
 /**
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  * @param {object} csnUtils
  * @param {string} pathDelimiter
  * @param {boolean} [processOnInQueries=false] Wether to process on-conditions in queries (joins and mixins)
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
  */
-function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries = false ) {
+function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnInQueries = false ) {
   const {
     inspectRef,
   } = csnUtils;
 
   return handleManagedAssocSteps;
 
+  /**
+   *
+   * @param {object} obj Object with annotations.
+   * @param {object} transformer Annotation expression transformers.
+   * @param {CSN.Path} path CSN path for locations.
+   */
+  function processRefsInAnnotations(obj, transformer, path) {
+    Object.keys(obj)
+      .filter(pn => pn.startsWith('@') && obj[pn])
+      .forEach((anno) => {
+      // TODO: Ensure we only do processing here for annotations that have refs, to save time
+        const annoBefore = JSON.stringify(obj[anno]);
+        transformAnnotationExpression(obj, anno, transformer, path);
+        if (obj[anno].ref)
+          transformer.ref(obj[anno], 'ref', obj[anno].ref, path.concat(anno));
+        const annoAfter = JSON.stringify(obj[anno]);
+        if (annoBefore !== annoAfter)
+          obj[anno]['='] = true;
+      });
+  }
+
   /**
    * Loop over all elements and for all unmanaged associations translate
    * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
@@ -133,6 +156,11 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
   function handleManagedAssocSteps( artifact, artifactName ) {
     const transformer = getTransformer();
     const inColumnsTransformer = getTransformer(true);
+
+    if (options.transformation === 'effective')
+      processRefsInAnnotations(artifact, transformer, [ 'definitions', artifactName ]);
+
+
     for (const elemName in artifact.elements) {
       const elem = artifact.elements[elemName];
       // The association is an unmanaged one
@@ -140,6 +168,10 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
         applyTransformationsOnNonDictionary(elem, 'on', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
       else if (elem.value?.stored)
         applyTransformationsOnNonDictionary(elem, 'value', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+
+      // TODO: Is this enough? I suppose that these annotations can be in places that are not an element.
+      if (options.transformation === 'effective')
+        processRefsInAnnotations(elem, transformer, [ 'definitions', artifactName, 'elements', elemName ]);
     }
 
     if (artifact.query || artifact.projection) {
@@ -165,6 +197,10 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
         };
         queryTransformers.on = transform;
       }
+
+      if (options.transformation === 'effective' || options.transformation === 'odata')
+        queryTransformers.xpr = transform;
+
       applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', queryTransformers, { drillRef: true }, [ 'definitions', artifactName ]);
     }
 

package/lib/transform/db/assocsToQueries/transformExists.js

@@ -26,30 +26,29 @@ const { getHelpers } = require('./utils');
  *   + Is it part of the source side: <path> is turned into <query source>.<path> - a leading $self is stripped-off
  *   + Is it something else: Don't touch it, leave as is
  *
- * Given that `assoc` from above has the on-condition assoc.id = id, we would generate the following:
+ * Given that `assoc` from above has the on-condition `assoc.id = id`, we would generate the following:
  * - F.id = E.id
  *
- * The final subselect looks like (select 1 as dummy from E where F.id = E.id and filter = 100).
+ * The final subselect looks like `(select 1 as dummy from E where F.id = E.id and filter = 100)`.
  *
  * For a $self backlink:
  * - For $self = <assoc>.<another-assoc>, we do the following for each foreign key of <another-assoc>
  *   + <assoc>.<another-assoc>.<fk> -> <assoc.target>.<another-assoc>.<fk>
- *   + Afterwards, we get the corresponding key from the source side: <query-source>.<fk>
+ *   + Afterward, we get the corresponding key from the source side: <query-source>.<fk>
  *   + And turn this into a comparison: <assoc.target>.<another-assoc>.<fk> = <query-source>.<fk>
  *
  * So for the sample above, given an on-condition like $self = assoc.backToE, we would generate:
  * - F.backToE.id = E.id
  *
- * The final subselect looks like (select 1 as dummy from E where F.backToE.id = E.id and filter = 100).
+ * The final subselect looks like `(select 1 as dummy from E where F.backToE.id = E.id and filter = 100)`.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param {Function} error
- * @param {Function} inspectRef
- * @param {Function} initDefinition
- * @param {Function} dropDefinitionCache
+ * @param {object} messageFunctions
+ * @param {object} csnUtils
  */
-function handleExists( csn, options, error, inspectRef, initDefinition, dropDefinitionCache ) {
+function handleExists( csn, options, messageFunctions, csnUtils ) {
+  const { error } = messageFunctions;
   const {
     getBase,
     firstLinkIsEntityOrQuerySource,
@@ -57,17 +56,12 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     translateManagedAssocToWhere,
     getQuerySources,
     translateUnmanagedAssocToWhere,
-  } = getHelpers(csn, inspectRef, error);
+  } = getHelpers(csn, csnUtils.inspectRef, error);
+
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
-    // drop cache: Otherwise, the projection/query hack below won't work, because csnRefs
-    // thinks that the artifact was already initialized (including all queries).
-    dropDefinitionCache(artifact);
-    if (artifact.projection) // do the same hack we do for the other stuff...
-      artifact.query = { SELECT: artifact.projection };
-
-    if (artifact.query) {
-      forAllQueries(artifact.query, function handleExistsQuery(query, path) {
+    if (artifact.query || artifact.projection) {
+      forAllQueries(artifact.query || { SELECT: artifact.projection }, function handleExistsQuery(query, path) {
         if (!generatedExists.has(query)) {
           const toProcess = []; // Collect all expressions we need to process here
           if (query.SELECT?.where?.length > 1)
@@ -90,8 +84,8 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           while (toProcess.length > 0) {
             const [ queryPath, exprPath ] = toProcess.pop();
             // Re-init caches for this artifact
-            dropDefinitionCache(artifact);
-            initDefinition(artifact);
+            csnUtils.dropDefinitionCache(artifact);
+            csnUtils.initDefinition(artifact);
             // leftovers can happen with nested exists - we then need to drill down into the created SELECT
             // to check for further exists
             const { result, leftovers } = processExists(queryPath, exprPath);
@@ -100,16 +94,10 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
             toProcess.push(...leftovers); // any leftovers - schedule for further processing
           }
           // Make sure we leave csnRefs usable
-          dropDefinitionCache(artifact);
-          initDefinition(artifact);
+          csnUtils.dropDefinitionCache(artifact);
+          csnUtils.initDefinition(artifact);
         }
-      }, [ 'definitions', artifactName, 'query' ]);
-    }
-
-    if (artifact.projection) { // undo our hack
-      artifact.projection = artifact.query.SELECT;
-
-      delete artifact.query;
+      }, [ 'definitions', artifactName, artifact.projection ? 'projection' : 'query' ]);
     }
   });
 
@@ -168,7 +156,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
       }
     }
     const stack = [ [ null, startAssoc, startRest, startIndex ] ];
-    const { links } = inspectRef(path);
+    const { links } = csnUtils.inspectRef(path);
     while (stack.length > 0) {
       // previous: to nest "up" if the previous assoc did not originally have a filter
       // assoc: the assoc path step
@@ -258,8 +246,9 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     const newExpr = [];
     const query = walkCsnPath(csn, queryPath);
     const expr = walkCsnPath(csn, exprPath);
-    const queryBase = query.SELECT.from.ref ? (query.SELECT.from.as || query.SELECT.from.ref) : null;
-    const sources = getQuerySources(query.SELECT);
+    const select = query.projection ?? query.SELECT;
+    const queryBase = select?.from?.ref ? (select.from.as || select.from.ref) : null;
+    const sources = getQuerySources(select);
 
     for (let i = 0; i < expr.length; i++) {
       if (i < expr.length - 1 && expr[i] === 'exists' && expr[i + 1].ref) {

package/lib/transform/db/assocsToQueries/utils.js

@@ -430,7 +430,7 @@ function getHelpers( csn, inspectRef, error ) {
   }
 
   /**
-   * Use cacjed _links and _art or calculate via inspectRef
+   * Use cached _links and _art or calculate via inspectRef
    * @param {object} obj
    * @param {CSN.Path} objPath
    * @returns {object}

package/lib/transform/db/cdsPersistence.js

@@ -125,7 +125,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
 
       recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
         // All elements must have a type for this to work
-        if (!member.$ignore && !member.kind && !member.type) {
+        if (!member.$ignore && !member.kind && !member.type && !member.elements) { // .items? Probably resolved at this point
           error(null, path, { anno: '@cds.persistence.table' },
                 'Expecting element to have a type if view is annotated with $(ANNO)');
         }

package/lib/transform/db/expansion.js

@@ -38,18 +38,16 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     columns: (parent, name, columns, path) => {
       const artifact = csn.definitions[path[1]];
       csnUtils.initDefinition(artifact); // potentially not initialized, yet
-      if (!artifact['@cds.persistence.table']) {
-        const root = csnUtils.get$combined({ SELECT: parent });
-        // TODO: replace with the correct options.transformation?
-        // Do not expand the * in OData for a moment, not to introduce changes
-        // while the OData CSN is still official
-        const isComplexQuery = parent.from.join !== undefined;
-        if (!options.toOdata)
-          parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
-        // FIXME(v6): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
-        // if we're inside the outermost "columns". If so, always prepend a table alias. See #11662
-        parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery || path.length > 4);
-      }
+      const root = csnUtils.get$combined({ SELECT: parent });
+      // TODO: replace with the correct options.transformation?
+      // Do not expand the * in OData for a moment, not to introduce changes
+      // while the OData CSN is still official
+      const isComplexQuery = parent.from.join !== undefined;
+      if (!options.toOdata)
+        parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
+      // FIXME(v6): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
+      // if we're inside the outermost "columns". If so, always prepend a table alias. See #11662
+      parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery || path.length > 4);
     },
     groupBy: (parent, name, groupBy, path) => {
       parent.groupBy = expand(groupBy, path.concat('groupBy'));
@@ -86,24 +84,22 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         // (which is the thing inside SET/SELECT)
         // We can directly use SELECT here, as only projections and SELECT can have .columns
         const root = csnUtils.get$combined({ SELECT: parent });
-        if (!artifact['@cds.persistence.table']) {
-          // Make root look like normal .elements - we never cared about conflict afaik anyway
-          Object.keys(root).forEach((key) => {
-            root[key] = root[key][0].element;
+        // Make root look like normal .elements - we never cared about conflict afaik anyway
+        Object.keys(root).forEach((key) => {
+          root[key] = root[key][0].element;
+        });
+        const rewritten = rewrite(root, parent.columns, parent.excluding);
+        /*
+          * Do not remove unexpandable many columns in OData
+        */
+        if (rewritten.toMany.length > 0 && !options.toOdata) {
+          markAsToDummify(artifact, path[1]);
+          rewritten.toMany.forEach(({ art }) => {
+            error( null, art.$path || [ 'definitions', path[1] ], { name: `${ art.$env || path[1] }:${ art.ref.map(r => r.id || r) }` }, 'Unexpected .expand with to-many association $(NAME)');
           });
-          const rewritten = rewrite(root, parent.columns, parent.excluding);
-          /*
-           * Do not remove unexpandable many columns in OData
-          */
-          if (rewritten.toMany.length > 0 && !options.toOdata) {
-            markAsToDummify(artifact, path[1]);
-            rewritten.toMany.forEach(({ art }) => {
-              error( null, art.$path || [ 'definitions', path[1] ], { name: `${ art.$env || path[1] }:${ art.ref.map(r => r.id || r) }` }, 'Unexpected .expand with to-many association $(NAME)');
-            });
-          }
-          else {
-            parent.columns = rewritten.columns;
-          }
+        }
+        else {
+          parent.columns = rewritten.columns;
         }
       },
     });
@@ -280,11 +276,13 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
       const allToMany = [];
       const newThing = [];
       const containsExpandInline = columns.some(col => col.expand || col.inline);
-      if (containsExpandInline) // Replace stars - needs to happen before resolving .expand/.inline since the .expand/.inline first path step affects the root *
-        columns = replaceStar(root, columns, excluding);
-      else
+      if (!containsExpandInline)
         return { columns, toMany: [] };
 
+      // Replace stars - needs to happen before resolving .expand/.inline since the
+      // .expand/.inline first path step affects the root *
+      columns = replaceStar(root, columns, excluding);
+
       for (const col of columns) {
         if (col.expand || col.inline) {
           const { expanded, toManys } = expandInline(root, col, col.ref || [], col.expand ? [ dbName(col) ] : []);
@@ -364,7 +362,10 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         }
         else if (current.on || current.cast?.on) {
           rewriteOn(current, [ currentAlias.slice(0, -1).join(pathDelimiter) ]);
-          expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
+          const expandedCol = Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } );
+          if (currentRef.length)
+            expandedCol.ref = currentRef;
+          expanded.push(expandedCol);
         }
         else if (current.val !== undefined || current.func !== undefined) {
           expanded.push(Object.assign(current, { as: currentAlias.join(pathDelimiter) }));
@@ -440,7 +441,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     function rewriteOnCondition( on, currentRef, stack ) {
       for (let i = 0; i < on.length; i++) {
         const part = on[i];
-        if (part.ref && part.ref[0] !== '$self' && part.ref[0] !== '$projection') {
+        if (part.ref && part.$scope !== '$magic' && part.$scope !== '$self' && part.$scope !== '$projection') {
           part.ref = currentRef[0] ? [ currentRef[0], ...part.ref ] : part.ref;
           on[i] = part;
           stack.push([ part, part.ref ]);
@@ -461,7 +462,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     function rewriteSingleExpressionArray( expressionArray, currentRef, stack ) {
       for (let i = 0; i < expressionArray.length; i++) {
         const part = expressionArray[i];
-        if (part.ref) {
+        if (part.ref && part.$scope !== '$magic' && part.$scope !== '$self') {
           part.ref = currentRef.concat(part.ref);
           expressionArray[i] = part;
           stack.push([ part, part.ref ]);
@@ -657,7 +658,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         obj.ref = [ root.$env, ...obj.ref ];
 
       if (iterateOptions.keepKeysOrigin) {
-        setProp(obj, '$originalKeyRef', { ref: root.ref, as: root.as });
+        setProp(obj, '$originalKeyRef', root);
         setProp(obj, '$path', root.$path);
       }
 

package/lib/transform/db/killAnnotations.js

@@ -26,6 +26,7 @@ const requiredAnnos = {
   '@Core.Computed': true,
   [sqlServiceAnnotation]: true,
   '@cds.external': true, // for external ABAP SQL services and data products for now
+  '@DataIntegration.dataproduct.type': true, // for data product production
 };
 
 /**

package/lib/transform/db/processSqlServices.js

@@ -16,12 +16,15 @@ const sqlServiceAnnotation = '@protocol';
 function processSqlServices(csn, options) {
   setProp(csn, '$sqlServiceEntities', Object.create(null));
   setProp(csn, '$dummyServiceEntities', Object.create(null));
+  setProp(csn, '$dataProductEntities', Object.create(null));
   return function findAndMarkSqlServiceArtifacts(artifact, artifactName) {
-    const { sqlServiceName, dummyServiceName } = isEntityInSqlService(artifact, artifactName, csn, options);
+    const { sqlServiceName, dummyServiceName, dataProductServiceName } = isEntityInSqlService(artifact, artifactName, csn, options);
     if (sqlServiceName?.length > 0)
       setProp(artifact, '$sqlService', sqlServiceName);
     if (dummyServiceName?.length > 0)
       setProp(artifact, '$dummyService', dummyServiceName);
+    if (dataProductServiceName?.length > 0)
+      setProp(artifact, '$dataProductService', dataProductServiceName);
   };
 }
 
@@ -55,7 +58,7 @@ function isDummyService(artifact, options) {
  * @returns {object} An object containing the names of the SQL service and external ABAP SQL service, if found.
  */
 function isEntityInSqlService(artifact, artifactName, csn, options) {
-  const result = { sqlServiceName: undefined, dummyServiceName: undefined };
+  const result = { sqlServiceName: undefined, dummyServiceName: undefined, dataProductServiceName: undefined };
   if (artifact.kind !== 'entity' || !artifactName.includes('.') || hasPersistenceSkipAnnotation(artifact))
     return result;
 
@@ -72,6 +75,9 @@ function isEntityInSqlService(artifact, artifactName, csn, options) {
     if (isDummyService(definition, options))
       result.dummyServiceName = possibleServiceName;
 
+    if (isDataProductService(definition, options))
+      result.dataProductServiceName = possibleServiceName;
+
     // We don't allow nested services/contexts - if we find one, we don't need to keep searching
     if (definition.kind === 'service' || definition.kind === 'context')
       return result;
@@ -108,10 +114,22 @@ function createServiceDummy(artifact, artifactName, csn, { error }) {
     csn.definitions[`dummy.${ artifactName }`] = dummy;
 }
 
+/**
+ * Determines if the given artifact is a data product service.
+ *
+ * @param {object} artifact - The artifact to evaluate.
+ * @param {object} options - The options object containing feature flags.
+ * @returns {boolean} - Returns `true` if the artifact is a data product service, otherwise `false`.
+ */
+function isDataProductService(artifact, options) {
+  return isBetaEnabled(options, 'projectionViews') && artifact.kind === 'service' && artifact['@DataIntegration.dataproduct.type'] === 'primary';
+}
+
 module.exports = {
   processSqlServices,
   isSqlService,
   isDummyService,
+  isDataProductService,
   sqlServiceAnnotation,
   createServiceDummy,
 };

package/lib/transform/draft/db.js

@@ -4,7 +4,7 @@ const {
   getServiceNames, forEachDefinition,
   getResultingName, forEachMemberRecursively, applyAnnotationsFromExtensions,
 } = require('../../model/csnUtils');
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
 const { ModelError } = require('../../base/error');
 const { forEach } = require('../../utils/objectUtils');
@@ -56,10 +56,10 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
 
       // Redirect associations/compositions between draft shadow nodes
       for (const name in draftNodes) {
-        const shadowNode = csn.definitions[`${name}${draftSuffix}`];
+        const shadowNode = csn.definitions[`${ name }${ draftSuffix }`];
         // Might not exist because of previous errors
         if (shadowNode)
-          redirectDraftTargets(csn.definitions[`${name}${draftSuffix}`], draftNodes);
+          redirectDraftTargets(csn.definitions[`${ name }${ draftSuffix }`], draftNodes);
       }
     }
   }
@@ -84,7 +84,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
         const draftNodeName = elem.target;
         // Sanity check
         if (!draftNode)
-          throw new ModelError(`Expecting target to be resolved: ${JSON.stringify(elem, null, 2)}`);
+          throw new ModelError(`Expecting target to be resolved: ${ JSON.stringify(elem, null, 2) }`);
 
         // Ignore composition if not part of a service
         if (!isPartOfService(draftNodeName)) {
@@ -115,11 +115,11 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
   function generateDraftForHana( artifact, artifactName, draftRootName ) {
     // Sanity check
     if (!isPartOfService(artifactName))
-      throw new ModelError(`Expecting artifact to be part of a service: ${JSON.stringify(artifact)}`);
+      throw new ModelError(`Expecting artifact to be part of a service: ${ JSON.stringify(artifact) }`);
 
 
     // The name of the draft shadow entity we should generate
-    const draftsArtifactName = `${artifactName}${draftSuffix}`;
+    const draftsArtifactName = `${ artifactName }${ draftSuffix }`;
 
     generatedArtifacts[draftsArtifactName] = true;
 
@@ -132,7 +132,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     // Ignore boolean return value. We know that we're inside a service or else we wouldn't have reached this code.
     const matchingService = getMatchingService(artifactName) || '';
     // Generate the DraftAdministrativeData projection into the service, unless there is already one
-    const draftAdminDataProjectionName = `${matchingService}.DraftAdministrativeData`;
+    const draftAdminDataProjectionName = `${ matchingService }.DraftAdministrativeData`;
     let draftAdminDataProjection = csn.definitions[draftAdminDataProjectionName];
     if (!draftAdminDataProjection) {
       generatedArtifacts[draftAdminDataProjectionName] = true;
@@ -232,10 +232,9 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     draftAdministrativeData.DraftAdministrativeData.notNull = true;
     addElement(draftAdministrativeData, draftsArtifact, artifactName);
 
-    if (isBetaEnabled(options, 'draftMessages') || options.draftMessages) {
-      const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
-      addElement(draftMessages, draftsArtifact, artifactName);
-    }
+    const draftMessages = { DraftMessages: { '@Core.Computed': true, virtual: true, items: { type: 'DRAFT.DraftAdministrativeData_DraftMessage' } } };
+    addElement(draftMessages, draftsArtifact, artifactName);
+
     // Note that we may need to do the HANA transformation steps for managed associations
     // (foreign key field generation, generatedFieldName, creating ON-condition) by hand,
     // because the corresponding transformation steps have already been done on all artifacts
@@ -278,18 +277,19 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
       const sourceElement = source.elements[draftUUIDKey.ref[0]];
       const targetElement = {};
       forEach(sourceElement, (key, value) => {
-        if(!key.startsWith('@') && key !== 'key')
+        if (!key.startsWith('@') && key !== 'key')
           targetElement[key] = value;
-      })
+      });
 
-      if(sourceElement.key) targetElement.notNull = true;
+      if (sourceElement.key)
+        targetElement.notNull = true;
 
-      draftsArtifact.elements['DraftAdministrativeData' + (options.sqlMapping === 'hdbcds' ? '.' : '_') + draftUUIDKey.ref[0]] =  targetElement;
+      draftsArtifact.elements[`DraftAdministrativeData${ options.sqlMapping === 'hdbcds' ? '.' : '_' }${ draftUUIDKey.ref[0] }`] = targetElement;
 
       draftAdministrativeData.DraftAdministrativeData.on = createAssociationPathComparison('DraftAdministrativeData',
                                                                                            getNameForRef(draftUUIDKey),
                                                                                            '=',
-                                                                                           `DraftAdministrativeData${pathDelimiter}DraftUUID`);
+                                                                                           `DraftAdministrativeData${ pathDelimiter }DraftUUID`);
       // The notNull has been transferred to the foreign key field and must be removed on the association
       delete draftAdministrativeData.DraftAdministrativeData.notNull;
 
@@ -337,9 +337,9 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     function getDraftShadowEntityFor( draftNode, draftNodeName ) {
       // Sanity check
       if (!draftNodes[draftNodeName])
-        throw new ModelError(`Not a draft node: ${draftNodeName}`);
+        throw new ModelError(`Not a draft node: ${ draftNodeName }`);
 
-      return { shadowTarget: csn.definitions[`${draftNodeName}${draftSuffix}`], shadowTargetName: `${draftNodeName}${draftSuffix}` };
+      return { shadowTarget: csn.definitions[`${ draftNodeName }${ draftSuffix }`], shadowTargetName: `${ draftNodeName }${ draftSuffix }` };
     }
   }
 
@@ -351,7 +351,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
    */
   function isPartOfService( artifactName ) {
     for (const serviceName of allServices) {
-      if (artifactName.startsWith(`${serviceName}.`))
+      if (artifactName.startsWith(`${ serviceName }.`))
         return true;
     }
 
@@ -369,7 +369,7 @@ function generateDrafts( csn, options, pathDelimiter, messageFunctions ) {
     /** @type {false|string} */
     let match = false;
     for (const serviceName of allServices) {
-      if (artifactName.startsWith(`${serviceName}.`) && (!match || serviceName.length < match.length))
+      if (artifactName.startsWith(`${ serviceName }.`) && (!match || serviceName.length < match.length))
         match = serviceName;
     }
     return match;