@sap/cds-compiler 2.13.6 → 2.15.4

package/lib/render/utils/common.js

@@ -2,6 +2,8 @@
 
 'use strict';
 
+const { ModelError } = require('../../base/error');
+
 const functionsWithoutParams = {
   hana: {
     CURRENT_CONNECTION: {},
@@ -280,12 +282,12 @@ const cdsToSqlTypes = {
 };
 
 /**
-   * Get the element matching the column
-   *
-   * @param {CSN.Elements} elements Elements of a query
-   * @param {CSN.Column} column Column from the same query
-   * @returns {CSN.Element}
-   */
+ * Get the element matching the column
+ *
+ * @param {CSN.Elements} elements Elements of a query
+ * @param {CSN.Column} column Column from the same query
+ * @returns {CSN.Element}
+ */
 function findElement(elements, column) {
   if (!elements)
     return undefined;
@@ -341,16 +343,17 @@ function hasHanaComment(obj, options) {
   return !options.disableHanaComments && typeof obj.doc === 'string';
 }
 /**
-   * Return the comment of the given artifact or element.
-   * Uses the first block (everything up to the first empty line (double \n)).
-   * Remove leading/trailing whitespace.
-   *
-   * @param {CSN.Artifact|CSN.Element} obj
-   * @returns {string}
-   * @todo Warning/info to user?
-   */
+ * Return the comment of the given artifact or element.
+ * Uses the first block (everything up to the first empty line (double \n)).
+ * Remove leading/trailing whitespace.
+ * Does not escape any characters.
+ *
+ * @param {CSN.Artifact|CSN.Element} obj
+ * @returns {string}
+ * @todo Warning/info to user?
+ */
 function getHanaComment(obj) {
-  return obj.doc.split('\n\n')[0].trim().replace(/'/g, "''");
+  return obj.doc.split('\n\n')[0].trim();
 }
 
 /**
@@ -368,6 +371,118 @@ function getSqlSnippets(options, obj) {
   return { front, back };
 }
 
+/**
+ * A function used to render a certain part of an expression object
+ *
+ * @callback renderPart
+ * @param {object||array} expression
+ * @param {CdlRenderEnvironment} env
+ * @this {{inline: Boolean, nestedExpr: Boolean}}
+ * @returns {string}
+ */
+
+/**
+ * The object containing the concrete rendering functions for the different parts
+ * of an expression
+ *
+ * @typedef {object} ExpressionConfiguration
+ * @property {(x: any) => string} finalize The final function to call on the expression(-string) before returning
+ * @property {renderPart} explicitTypeCast
+ * @property {renderPart} val
+ * @property {renderPart} enum
+ * @property {renderPart} ref
+ * @property {renderPart} aliasOnly
+ * @property {renderPart} windowFunction
+ * @property {renderPart} func
+ * @property {renderPart} xpr
+ * @property {renderPart} SELECT
+ * @property {renderPart} SET
+ */
+
+/**
+ * Render an expression (including paths and values) or condition 'x'.
+ * (no trailing LF, don't indent if inline)
+ *
+ * @param {ExpressionConfiguration} renderer
+ * @returns {Function} Rendered expression
+ */
+function getExpressionRenderer(renderer) {
+  /**
+   * Render an expression (including paths and values) or condition 'x'.
+   * (no trailing LF, don't indent if inline)
+   *
+   * @todo Reuse this with toCdl
+   * @param {Array|object|string} expr Expression to render
+   * @param {object} env Render environment
+   * @param {boolean} [inline=true] Whether to render the expression inline
+   * @param {boolean} [nestedExpr=false] Whether to treat the expression as nested
+   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `nestedExpr === false`.
+   *                                           Note: This is a hack for casts() inside groupBy.
+   * @returns {string} Rendered expression
+   */
+  return function renderExpr(expr, env, inline = true, nestedExpr = false, alwaysRenderCast = false) {
+  // Compound expression
+    if (Array.isArray(expr)) {
+      const tokens = expr.map(item => renderExpr(item, env, inline, nestedExpr));
+      return beautifyExprArray(tokens);
+    }
+    else if (typeof expr === 'object' && expr !== null) {
+      if ((nestedExpr || alwaysRenderCast) && expr.cast && expr.cast.type && !expr.cast.target)
+        return renderer.explicitTypeCast.call({ inline, nestedExpr }, expr, env);
+      return renderExprObject(expr);
+    }
+    // Not a literal value but part of an operator, function etc - just leave as it is
+    // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
+    return renderer.finalize.call({ inline, nestedExpr }, expr, env);
+
+
+    /**
+     * Various special cases represented as objects
+     *
+     * @param {object} x Expression
+     * @returns {string} String representation of the expression
+     */
+    function renderExprObject(x) {
+      if (x.list) { // TODO: Does this still exist?
+        return `(${x.list.map(item => renderExpr(item, env, inline, false)).join(', ')})`;
+      }
+      else if (x.val !== undefined) {
+        return renderer.val.call({ inline, nestedExpr }, x, env);
+      }
+      // Enum symbol
+      else if (x['#']) {
+        return renderer.enum.call({ inline, nestedExpr }, x, env);
+      }
+      // Reference: Array of path steps, possibly preceded by ':'
+      else if (x.ref) {
+        return renderer.ref.call({ inline, nestedExpr }, x, env);
+      }
+      // Function call, possibly with args (use '=>' for named args)
+      else if (x.func) {
+        if (x.xpr)
+          return renderer.windowFunction.call({ inline, nestedExpr }, x, env);
+        return renderer.func.call({ inline, nestedExpr }, x, env);
+      }
+      // Nested expression
+      else if (x.xpr) {
+        return renderer.xpr.call({ inline, nestedExpr }, x, env);
+      }
+      // Sub-select
+      else if (x.SELECT) {
+        return renderer.SELECT.call({ inline, nestedExpr }, x, env);
+      }
+      else if (x.SET) {
+        return renderer.SET.call({ inline, nestedExpr }, x, env);
+      }
+      else if (x.as && x.cast && x.cast.type && x.cast.target) {
+        return renderer.aliasOnly.call({ inline, nestedExpr }, x, env);
+      }
+
+      throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
+    }
+  };
+}
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *
@@ -386,6 +501,7 @@ function getSqlSnippets(options, obj) {
 
 module.exports = {
   renderFunc,
+  getExpressionRenderer,
   beautifyExprArray,
   getNamespace,
   getRealName,

package/lib/transform/db/.eslintrc.json

@@ -8,7 +8,7 @@
     "prefer-template": "error",
     "no-trailing-spaces": "error",
     "template-curly-spacing":["error", "never"],
-    "complexity": ["warn", 30],
+    "complexity": ["warn", 40],
     "max-len": "off",
     // Don't enforce stupid descriptions
     "jsdoc/require-param-description": "off",

package/lib/transform/db/associations.js

@@ -37,7 +37,7 @@ function attachOnConditions(csn, pathDelimiter) {
   /**
    * Create the foreign key elements for a managed association and build the on-condition
    *
-   * @param {Object} elem The association to process
+   * @param {object} elem The association to process
    * @param {string} elemName
    * @returns {void}
    */
@@ -167,7 +167,7 @@ function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
      *
      * @param {Array} links
      * @param {number} startIndex
-     * @returns {Object| undefined} CSN definition of the source of the managed association
+     * @returns {object | undefined} CSN definition of the source of the managed association
      */
     function findSource(links, startIndex) {
       for (let i = startIndex; i >= 0; i--) {

package/lib/transform/db/constraints.js

@@ -277,7 +277,9 @@ function createReferentialConstraints(csn, options) {
     // no constraint if either dependent or parent is not persisted
     if (
       hasAnnotationValue(parent, '@cds.persistence.skip') ||
-      hasAnnotationValue(dependent, '@cds.persistence.skip')
+      hasAnnotationValue(dependent, '@cds.persistence.skip') ||
+      hasAnnotationValue(parent, '@cds.persistence.exists') ||
+      hasAnnotationValue(dependent, '@cds.persistence.exists')
     )
       return true;
 

package/lib/transform/db/expansion.js

@@ -8,6 +8,7 @@ const {
 } = require('../../model/csnUtils');
 const { csnRefs, implicitAs } = require('../../model/csnRefs');
 const { setProp, isBetaEnabled } = require('../../base/model');
+const { forEach } = require('../../utils/objectUtils');
 
 /**
  * For keys, columns, groupBy and orderBy, expand structured things.
@@ -19,10 +20,10 @@ const { setProp, isBetaEnabled } = require('../../base/model');
  * @param {object} messageFunctions
  * @param {Function} messageFunctions.error
  * @param {Function} messageFunctions.info
- * @param {Function} messageFunctions.throwWithError
+ * @param {Function} messageFunctions.throwWithAnyError
  * @param {object} iterateOptions
  */
-function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithError }, iterateOptions = {}) {
+function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {}) {
   const {
     isStructured, get$combined, getFinalBaseType, getServiceName,
   } = getUtils(csn);
@@ -182,7 +183,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     }
 
     // We would be broken if we continue with assoc usage to now skipped
-    throwWithError();
+    throwWithAnyError();
 
 
     for (const {
@@ -211,7 +212,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       while (stack.length > 0) {
         const [ a, n ] = stack.pop();
         if (a[_dependents]) {
-          Object.entries(a[_dependents]).forEach(([ dependentName, dependent ]) => {
+          forEach(a[_dependents], (dependentName, dependent) => {
             stack.push([ dependent, dependentName ]);
           });
         }
@@ -253,7 +254,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     /**
      * Rewrite expand and inline to "normal" refs
      *
-     * @param {CSN.Artifact} root All elements visible fromt he query source ($combined)
+     * @param {CSN.Artifact} root All elements visible from the query source ($combined)
      * @param {CSN.Column[]} columns
      * @param {string[]} excluding
      * @returns {{columns: Array, toMany: Array}} Object with rewritten columns (.expand/.inline) and with any .expand + to-many
@@ -261,8 +262,12 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     function rewrite(root, columns, excluding) {
       const allToMany = [];
       const newThing = [];
-      // Replace stars - needs to happen here since the .expand/.inline first path step affects the root *
-      columns = replaceStar(root, columns, excluding);
+      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
+        return { columns, toMany: [] };
+
       for (const col of columns) {
         if (col.expand) {
           // TODO: Can col.ref be empty without an as? Assumption is it cannot - if it has, it's an error, we throw, compiler checks.
@@ -402,8 +407,8 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @returns {string|null} Name of any entity
      */
     function findAnEntity() {
-      for (const [ name, artifact ] of Object.entries(csn.definitions)) {
-        if (artifact.kind === 'entity' && !artifact.query)
+      for (const name in csn.definitions) {
+        if (Object.hasOwnProperty.call(csn.definitions, name) && csn.definitions[name].kind === 'entity' && !csn.definitions[name].query)
           return name;
       }
       return null;
@@ -544,7 +549,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
   /**
    * Replace the star and correctly put shadowed things in the right place.
    *
-   * @param {Object} base The raw set of things a * can expand to
+   * @param {object} base The raw set of things a * can expand to
    * @param {Array} subs Things - the .expand/.inline or .columns
    * @param {string[]} [excluding=[]]
    * @returns {Array} If there was a star, expand it and handle shadowing/excluding, else just return subs

package/lib/transform/db/flattening.js

@@ -3,12 +3,13 @@
 const {
   getUtils, walkCsnPath,
   applyTransformations, applyTransformationsOnNonDictionary,
-  isBuiltinType, cloneCsn,
+  isBuiltinType, cloneCsnNonDict,
   copyAnnotations, implicitAs, isDeepEqual,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtilsNew');
 const { csnRefs } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
+const { forEach } = require('../../utils/objectUtils');
 
 /**
  * Strip off leading $self from refs where applicable
@@ -74,17 +75,20 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
     iterateOptions.skipDict.actions = true;
   else
     iterateOptions.skipDict = { actions: true };
+
+  const ignoreOdataKinds = { aspect: 1, event: 1, type: 1 };
+  const replaceWithDummyKinds = { action: 1, function: 1, event: 1 };
   applyTransformations(csn, {
-    cast: (parent) => {
+    cast: (parent, prop, cast, path) => {
       // Resolve cast already - we otherwise lose .localized
-      if (parent.cast.type && !isBuiltinType(parent.cast.type))
+      if (cast.type && !isBuiltinType(cast.type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(cast.type, path) && !isODataItems(cast.type)))
         toFinalBaseType(parent.cast, resolved, true);
     },
     // @ts-ignore
-    type: (parent, prop, type, csnPath) => {
-      if (options.toOdata && parent.kind && [ 'aspect', 'event', 'type' ].includes(parent.kind))
+    type: (parent, prop, type, path) => {
+      if (options.toOdata && parent.kind && parent.kind in ignoreOdataKinds)
         return;
-      if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type) && !isODataItems(type))) {
+      if (!isBuiltinType(type) && (!options.toOdata || options.toOdata && !isODataV4BuiltinFromService(type, path) && !isODataItems(type))) {
         toFinalBaseType(parent, resolved);
         // structured types might not have the child-types replaced.
         // Drill down to ensure this.
@@ -110,40 +114,6 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
         parent.type = 'cds.LargeString';
         delete parent.items;
       }
-
-      /**
-       * OData V4 only:
-       * Do not replace a type ref if:
-       * The type definition is terminating on a scalar type (that can also be a derived type chain)
-       * AND the typeName (that is the start of that (derived) type chain is defined within the same
-       * service as the artifact from which the type reference has to be resolved.
-       *
-       * @param {string} typeName
-       * @returns {boolean}
-       */
-      function isODataV4BuiltinFromService(typeName) {
-        if (!options.toOdata || (options.toOdata && options.toOdata.version === 'v2'))
-          return false;
-
-        const typeServiceName = getServiceName(typeName);
-        const finalBaseType = getFinalBaseType(typeName);
-        // we need the service of the current definition
-        const currDefServiceName = getServiceName(csnPath[1]);
-
-        return typeServiceName === currDefServiceName && isBuiltinType(finalBaseType);
-      }
-
-      /**
-       * OData stops replacing types @ 'items', if the type ref is a user defined type
-       * AND that type has items, don't do toFinalBaseType
-       *
-       * @param {string} typeName
-       * @returns {boolean}
-       */
-      function isODataItems(typeName) {
-        const typeDef = csn.definitions[typeName];
-        return !!(options.toOdata && typeDef && typeDef.items);
-      }
     },
     // HANA/SQLite do not support array-of - turn into CLOB/Text
     items: (parent) => {
@@ -159,8 +129,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
 
     // Do not do for OData
     // TODO:factor out somewhere else
-    if (!options.toOdata &&
-      ([ 'action', 'function', 'event' ].includes(artifact.kind))) {
+    if (!options.toOdata && artifact.kind in replaceWithDummyKinds) {
       const dummy = { kind: artifact.kind };
       if (artifact.$location)
         setProp(dummy, '$location', artifact.$location);
@@ -169,6 +138,42 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter, iterateOpt
     }
     // TODO: skipDict options as default function arguments not via Object.assign
   } ], iterateOptions);
+
+
+  /**
+   * OData V4 only:
+   * Do not replace a type ref if:
+   * The type definition is terminating on a scalar type (that can also be a derived type chain)
+   * AND the typeName (that is the start of that (derived) type chain is defined within the same
+   * service as the artifact from which the type reference has to be resolved.
+   *
+   * @param {string} typeName
+   * @param {CSN.Path} path
+   * @returns {boolean}
+   */
+  function isODataV4BuiltinFromService(typeName, path) {
+    if (!options.toOdata || (options.toOdata && options.toOdata.version === 'v2') || typeof typeName !== 'string')
+      return false;
+
+    const typeServiceName = getServiceName(typeName);
+    const finalBaseType = getFinalBaseType(typeName);
+    // we need the service of the current definition
+    const currDefServiceName = getServiceName(path[1]);
+
+    return typeServiceName === currDefServiceName && isBuiltinType(finalBaseType);
+  }
+
+  /**
+   * OData stops replacing types @ 'items', if the type ref is a user defined type
+   * AND that type has items, don't do toFinalBaseType
+   *
+   * @param {string} typeName
+   * @returns {boolean}
+   */
+  function isODataItems(typeName) {
+    const typeDef = csn.definitions[typeName];
+    return !!(options.toOdata && typeDef && typeDef.items);
+  }
 }
 
 /**
@@ -258,7 +263,7 @@ function flattenAllStructStepsInRefs(csn, options, resolved, pathDelimiter, iter
  * @param {CSN.Options} options
  * @param {string} pathDelimiter
  * @param {Function} error
- * @param {Object} iterateOptions
+ * @param {object} iterateOptions
  */
 function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}) {
   const { isAssocOrComposition } = getUtils(csn);
@@ -284,7 +289,7 @@ function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}
   function flatten(parent, prop, dict, path) {
     if (!parent[prop].$orderedElements)
       setProp(parent[prop], '$orderedElements', []);
-    Object.entries(dict).forEach(([ elementName, element ]) => {
+    forEach(dict, (elementName, element) => {
       if (element.elements) {
         // Ignore the structured element, replace it by its flattened form
         // TODO: use $ignore - _ is for links
@@ -295,9 +300,9 @@ function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}
 
         for (const flatElemName in flatElems) {
           if (parent[prop][flatElemName])
-          // TODO: combine message ID with generated FK duplicate
-          // do the duplicate check in the consruct callback, requires to mark generated flat elements,
-          // check: Error location should be the existing element like @odata.foreignKey4
+            // TODO: combine message ID with generated FK duplicate
+            // do the duplicate check in the consruct callback, requires to mark generated flat elements,
+            // check: Error location should be the existing element like @odata.foreignKey4
             error(null, path.concat([ 'elements', elementName ]), `"${path[1]}.${elementName}": Flattened struct element name conflicts with existing element: "${flatElemName}"`);
 
           const flatElement = flatElems[flatElemName];
@@ -315,16 +320,16 @@ function flattenElements(csn, options, pathDelimiter, error, iterateOptions = {}
                 const firstRef = onPart.ref[0];
 
                 /*
-                    when element is defined in the current name resolution scope, like
-                      entity E {
-                        key x: Integer;
-                            s : {
-                            y : Integer;
-                            a3 : association to E on a3.x = y;
-                            }
-                      }
-                    We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
-                  */
+                  when element is defined in the current name resolution scope, like
+                    entity E {
+                      key x: Integer;
+                          s : {
+                          y : Integer;
+                          a3 : association to E on a3.x = y;
+                          }
+                    }
+                  We need to replace y with s_y and a3 with s_a3 - we must take care to not escape our local scope
+                */
                 const prefix = flatElement._flatElementNameWithDots.split('.').slice(0, -1).join(pathDelimiter);
                 const possibleFlatName = prefix + pathDelimiter + firstRef;
 
@@ -418,11 +423,11 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
           }
         });
       },
-    }, [], {
+    }, [], Object.assign({
       skipIgnore: false,
       allowArtifact: artifact => (artifact.kind === 'entity' || artifact.kind === 'type'),
       skipDict: { actions: true },
-    });
+    }, iterateOptions));
   }
   createForeignKeyElements();
 
@@ -469,7 +474,7 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
           const flat = flattenStructuredElement(art, ref[ref.length - 1], [], pathToKey);
           Object.keys(flat).forEach((flatElemName) => {
             const key = assoc.keys[i];
-            const clone = cloneCsn(assoc.keys[i], options);
+            const clone = cloneCsnNonDict(assoc.keys[i], options);
             if (clone.as) {
               const lastRef = clone.ref[clone.ref.length - 1];
               // Cut off the last ref part from the beginning of the flat name
@@ -533,7 +538,7 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
      * @returns {object} The clone of base
      */
     function cloneAndExtendRef(key, base, ref) {
-      const clone = cloneCsn(base, options);
+      const clone = cloneCsnNonDict(base, options);
       if (key.ref) {
         // We build a ref that contains the aliased fk - that element will be created later on, so this ref is not resolvable yet
         // Therefore we keep it as $ref - ref is the non-aliased, resolvable "clone"
@@ -574,10 +579,7 @@ function handleManagedAssociationsAndCreateForeignKeys(csn, options, error, path
     if (options.toOdata)
       transformers.params = createFks;
 
-    // Do not respect _ignore flag for toOdata and toRename (we may have facades for existing HANA CDS
-    // artifacts that shall still be maintained from outside, filter them away in the rename script)
-    iterateOptions.skipIgnore = !(options.toOdata || options.toRename);
-    applyTransformations(csn, transformers, [], iterateOptions);
+    applyTransformations(csn, transformers, [], Object.assign({ skipIgnore: false }, iterateOptions));
 
     /**
      * Process a given .elements or .params dictionary and create foreign key elements
@@ -685,17 +687,21 @@ function createForeignKeysInternal(path, element, prefix, csn, options, pathDeli
     return fks;
 
   let finalElement = element;
+  let finalTypeName; // TODO: Find a way to not rely on $path?
   // TODO: effectiveType's return value is 'path' for the next inspectRef
   if (element.type && !isBuiltinType(element.type)) {
     const tmpElt = effectiveType(element);
     // effective type resolves to structs and enums only but not scalars
     if (Object.keys(tmpElt).length) {
       finalElement = tmpElt;
+      finalTypeName = finalElement.$path[1];
     }
     else {
       // unwind a derived type chain to a scalar type
-      while (finalElement.type && !isBuiltinType(finalElement.type))
+      while (finalElement.type && !isBuiltinType(finalElement.type)) {
+        finalTypeName = finalElement.type;
         finalElement = csn.definitions[finalElement.type];
+      }
     }
   }
 
@@ -712,7 +718,7 @@ function createForeignKeysInternal(path, element, prefix, csn, options, pathDeli
     }
     // TODO: has managed assoc keys?
     finalElement.keys.forEach((key, keyIndex) => {
-      const continuePath = isInspectRefResult ? [ path, 'keys', keyIndex ] : [ ...path, 'keys', keyIndex ];
+      const continuePath = getContinuePath([ 'keys', keyIndex ]);
       const alias = key.as || implicitAs(key.ref);
       const result = inspectRef(continuePath);
       fks = fks.concat(createForeignKeysInternal(result, result.art, alias, csn, options, pathDelimiter, lvl + 1));
@@ -738,12 +744,33 @@ function createForeignKeysInternal(path, element, prefix, csn, options, pathDeli
     Object.entries(finalElement.elements).forEach(([ elemName, elem ]) => {
       // Skip already produced foreign keys
       if (!elem['@odata.foreignKey4']) {
-        const continuePath = isInspectRefResult ? [ path, 'elements', elemName ] : [ ...path, 'elements', elemName ];
+        const continuePath = getContinuePath([ 'elements', elemName ]);
         fks = fks.concat(createForeignKeysInternal(continuePath, elem, elemName, csn, options, pathDelimiter, lvl + 1));
       }
     });
   }
 
+  /**
+   * Get the path to continue resolving references
+   *
+   * If we are currently inside of a type, we need to start our path fresh from that given type.
+   * Otherwise, we would try to resolve .elements on a thing that does not exist.
+   *
+   * We also respect if we have a previous inspectRef result as our base.
+   *
+   * @param {Array} additions
+   * @returns {CSN.Path}
+   */
+  function getContinuePath(additions) {
+    if (csn.definitions[finalElement.type])
+      return [ 'definitions', finalElement.type, ...additions ];
+    else if (finalTypeName)
+      return [ 'definitions', finalTypeName, ...additions ];
+    else if (isInspectRefResult)
+      return [ path, ...additions ];
+    return [ ...path, ...additions ];
+  }
+
   fks.forEach((fk) => {
     // prepend current prefix
     fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;

package/lib/transform/db/transformExists.js

@@ -110,8 +110,8 @@ function handleExists(csn, options, error) {
         sources[join.as] = join.as;
       }
       else if (join.args) {
-        const subsources = getJoinSources(join.args);
-        sources = Object.assign(sources, subsources);
+        const subSources = getJoinSources(join.args);
+        sources = Object.assign(sources, subSources);
       }
       else if (join.ref) {
         sources[join.ref[join.ref.length - 1]] = join.ref[join.ref.length - 1];
@@ -196,7 +196,7 @@ function handleExists(csn, options, error) {
     const stack = [ [ null, startAssoc, startRest, startIndex ] ];
     const { links } = inspectRef(path);
     while (stack.length > 0) {
-      // previous: to nest "up" if the previous assoc did not originaly have a filter
+      // previous: to nest "up" if the previous assoc did not originally have a filter
       // assoc: the assoc path step
       // rest: path steps after assoc
       // index: index of after-assoc in the overall ref-array - so we know where to start looking for the next assoc
@@ -411,14 +411,14 @@ function handleExists(csn, options, error) {
    * Translate an `EXISTS <managed assoc>` into a part of a WHERE condition.
    *
    * For each of the foreign keys, do:
-   * + build the target side by prefixing `target` infront of the ref
+   * + build the target side by prefixing `target` in front of the ref
    * + build the source side by prefixing `base` (if not already part of `current`)
-   *  and the assoc name itself (current) infront of the ref
+   *  and the assoc name itself (current) in front of the ref
    * + Compare source and target with `=`
    *
    * If there is more than one foreign key, join with `and`.
    *
-   * The new tokens are immediatly added to the WHERE of the subselect
+   * The new tokens are immediately added to the WHERE of the subselect
    *
    * @param {CSN.Element} root
    * @param {string} target
@@ -752,7 +752,7 @@ function handleExists(csn, options, error) {
    *
    * @param {string} target
    * @param {TokenStream} where
-   * @returns {TokenStream} The input-where with the refs "absolutified"
+   * @returns {TokenStream} The input-where with the refs transformed to absolute ones
    */
   function remapExistingWhere(target, where) {
     return where.map((part) => {