Improve reference detection for aliases

Author: oklemenz2

CHANGELOG.md

@@ -5,11 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## Version 0.2.2 - 2025-07-xx
+## Version 0.2.2 - 2025-06-26
 
 ### Fixed
 
-- tbd
+- Improve reference detection for aliases
 
 ## Version 0.2.1 - 2025-06-26
 

db/schema.cds

@@ -33,9 +33,11 @@ entity Pages {
                       on quotes.page = $self;
 }
 
-entity PagesView as select from Pages mixin {
+entity PagesView as select from Pages as pages mixin {
     mixinBook    : Association to Books on ID = ID;
 } into {
+    pages.ID,
+    pages.no,
     *,
     mixinBook
 } where mixinBook.ID = ID;

src/replication-cache/ReplicationCache.js

@@ -875,27 +875,68 @@ function selectFromRefs(model, query) {
   return refs;
 }
 
+function selectFromAliases(model, query) {
+  let aliases = {};
+  if (query.SELECT.from.SELECT) {
+    // Sub-select aliases are not (yet) supported
+  } else if (query.SELECT.from.ref) {
+    const ref = resolveRef(model, query.SELECT.from.ref);
+    if (query.SELECT.from.as) {
+      aliases[query.SELECT.from.as] = ref;
+    } else {
+      const as = ref.split(".").pop();
+      aliases[as] = ref;
+    }
+  } else if ((query.SELECT.from.join || query.SELECT.from.SET) && query.SELECT.from.args) {
+    for (const arg of query.SELECT.from.args) {
+      const ref = resolveRef(model, arg.ref);
+      if (arg.as) {
+        aliases[arg.as] = ref;
+      } else {
+        const as = ref.split(".").pop();
+        aliases[as] = ref;
+      }
+    }
+  }
+  return aliases;
+}
+
 function selectRefs(model, query) {
   let refs = selectFromRefs(model, query);
+  const aliases = selectFromAliases(model, query);
   if (query._target) {
     const target = model.definitions[query._target.name];
     if (query.SELECT.orderBy) {
-      refs = refs.concat(expressionRefs(model, target, query.SELECT.orderBy, query.SELECT.mixin));
+      refs = refs.concat(expressionRefs(model, target, query.SELECT.orderBy, query.SELECT.mixin, aliases));
     }
     if (query.SELECT.columns) {
-      refs = refs.concat(expressionRefs(model, target, query.SELECT.columns, query.SELECT.mixin));
-      refs = refs.concat(expandRefs(model, target, query.SELECT.columns, query.SELECT.mixin));
+      refs = refs.concat(expressionRefs(model, target, query.SELECT.columns, query.SELECT.mixin, aliases));
+      refs = refs.concat(expandRefs(model, target, query.SELECT.columns, query.SELECT.mixin, aliases));
     }
     if (query.SELECT.where) {
-      refs = refs.concat(expressionRefs(model, target, query.SELECT.where, query.SELECT.mixin));
+      refs = refs.concat(expressionRefs(model, target, query.SELECT.where, query.SELECT.mixin, aliases));
     }
     if (query.SELECT.having) {
-      refs = refs.concat(expressionRefs(model, target, query.SELECT.having, query.SELECT.mixin));
+      refs = refs.concat(expressionRefs(model, target, query.SELECT.having, query.SELECT.mixin, aliases));
     }
   }
   return refs;
 }
 
+function resolveRef(model, refs) {
+  let ref = refs[0];
+  if (ref.id) {
+    ref = ref.id;
+  }
+  let current = model.definitions[ref];
+  for (const ref of refs.slice(1)) {
+    if (current.elements[ref].type === "cds.Association" || current.elements[ref].type === "cds.Composition") {
+      current = current.elements[ref]._target;
+    }
+  }
+  return current.name;
+}
+
 function resolveRefs(model, refs) {
   let resolvedRefs = [];
   let ref = refs[0];
@@ -917,17 +958,16 @@ function resolveRefs(model, refs) {
   return resolvedRefs;
 }
 
-function identifierRefs(model, definition, expressions, mixin) {
+function identifierRefs(model, definition, expressions, mixins, aliases) {
   let refs = [];
   for (const expression of expressions) {
     if (Array.isArray(expression.ref)) {
       let current = definition;
-      let currentMixin = mixin;
+      let currentMixins = mixins;
       for (const ref of expression.ref) {
-        const element = current.elements[ref] || currentMixin?.[ref];
-        if (element.type === "cds.Association" || element.type === "cds.Composition") {
-          current = model.definitions[element.target];
-          currentMixin = {};
+        current = target(model, current, currentMixins, aliases, ref);
+        if (current !== null) {
+          currentMixins = {};
           refs.push(current.name);
         }
       }
@@ -936,30 +976,29 @@ function identifierRefs(model, definition, expressions, mixin) {
   return refs;
 }
 
-function expressionRefs(model, definition, expressions, mixin) {
-  let refs = identifierRefs(model, definition, expressions, mixin);
+function expressionRefs(model, definition, expressions, mixins, aliases) {
+  let refs = identifierRefs(model, definition, expressions, mixins, aliases);
   for (const expression of expressions) {
     if (expression.xpr) {
-      refs = refs.concat(expressionRefs(model, definition, expression.xpr, mixin));
+      refs = refs.concat(expressionRefs(model, definition, expression.xpr, mixins, aliases));
     } else if (expression.args) {
-      refs = refs.concat(expressionRefs(model, definition, expression.args, mixin));
+      refs = refs.concat(expressionRefs(model, definition, expression.args, mixins, aliases));
     } else if (expression.SELECT) {
       refs = refs.concat(selectRefs(model, expression));
     }
   }
   return refs;
 }
 
-function expandRefs(model, definition, columns, mixin) {
+function expandRefs(model, definition, columns, mixins, aliases) {
   let refs = [];
   for (const column of columns) {
     if (Array.isArray(column.ref) && column.expand) {
       let current = definition;
-      let currentMixin = mixin;
+      let currentMixins = mixins;
       for (const ref of column.ref) {
-        const element = current.elements[ref] || currentMixin?.[ref];
-        current = model.definitions[element.target];
-        currentMixin = {};
+        current = target(model, current, currentMixins, aliases, ref);
+        currentMixins = {};
         refs.push(current.name);
       }
       refs = refs.concat(expandRefs(model, current, column.expand));
@@ -968,6 +1007,26 @@ function expandRefs(model, definition, columns, mixin) {
   return refs;
 }
 
+function target(model, entity, mixins, aliases, ref) {
+  if (aliases?.[ref]) {
+    return typeof aliases[ref] === "string" ? model.definitions[aliases[ref]] : aliases[ref];
+  }
+  if (entity.name.endsWith(`.${ref}`)) {
+    return entity;
+  }
+  const element = entity.elements[ref] || mixins?.[ref];
+  if (!element) {
+    cds.log(Component).warn("Reference not found in entity", {
+      entity: entity.name,
+      ref,
+    });
+  }
+  if (element.type === "cds.Association" || element.type === "cds.Composition") {
+    return model.definitions[element.target];
+  }
+  return null;
+}
+
 function staticRefs(model, refs) {
   for (const ref of refs) {
     if (!model.definitions[ref][Annotations.ReplicateStatic]) {