@cap-js-community/common 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -0,0 +1,79 @@
+# Changelog
+
+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.3 - 2025-07-01
+
+### Fixed
+
+- Improve reference detection
+
+## Version 0.2.2 - 2025-06-26
+
+### Fixed
+
+- Improve reference detection for aliases
+
+## Version 0.2.1 - 2025-06-26
+
+### Fixed
+
+- Improve reference detection
+- Static non-tenant aware replication via `cds.replicate.static`
+
+## Version 0.2.0 - 2025-06-03
+
+### Fixed
+
+- CDS 9 compatibility
+
+## Version 0.1.7 - 2025-05-08
+
+### Fixed
+
+- Enabling journal mode and changing entity in same cycle is not allowed
+
+## Version 0.1.6 - 2025-05-07
+
+### Fixed
+
+- Redis 4
+
+## Version 0.1.5 - 2025-05-05
+
+### Fixed
+
+- Dependencies
+
+## Version 0.1.4 - 2025-04-10
+
+### Fixed
+
+- Improvements
+
+## Version 0.1.3 - 2025-04-10
+
+### Fixed
+
+- Redis client improvements
+
+## Version 0.1.2 - 2025-04-09
+
+### Fixed
+
+- Improvements
+
+## Version 0.1.1 - 2025-04-09
+
+### Fixed
+
+- Improvements
+
+## Version 0.1.0 - 2025-04-09
+
+### Added
+
+- Internal release

package/README.md

@@ -121,6 +121,7 @@ Options can be passed to migration check via CDS environment via `cds.migrationC
 
 - Maintain the whitelist extension file `migration-extension-whitelist.json` for compatible changes:
   - **Whitelist Entity**:
+
   ```json
   {
     "definitions": {
@@ -128,7 +129,9 @@ Options can be passed to migration check via CDS environment via `cds.migrationC
     }
   }
   ```
+
   - **Whitelist Entity Element**:
+
   ```json
   {
     "definitions": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/common",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "CAP Node.js Community Common",
   "homepage": "https://cap.cloud.sap/",
   "engines": {
@@ -20,7 +20,8 @@
     "bin",
     "src",
     "LICENSE",
-    "cds-plugin.js"
+    "cds-plugin.js",
+    "CHANGELOG.md"
   ],
   "main": "index.js",
   "types": "index.d.ts",
@@ -55,14 +56,14 @@
     "@sap/cds": "^9.0.4",
     "@sap/cds-common-content": "^3.0.1",
     "@sap/cds-dk": "^9.0.5",
-    "eslint": "9.29.0",
+    "eslint": "9.30.0",
     "eslint-config-prettier": "10.1.5",
     "eslint-plugin-jest": "29.0.1",
     "eslint-plugin-n": "^17.20.0",
     "jest": "30.0.3",
     "jest-html-reporters": "3.1.7",
     "jest-junit": "16.0.0",
-    "prettier": "3.6.1",
+    "prettier": "3.6.2",
     "shelljs": "^0.10.0"
   },
   "cds": {

package/src/replication-cache/ReplicationCache.js

@@ -178,7 +178,7 @@ class ReplicationCache {
       if (fromRefs.length === 0 || !this.relevant(fromRefs)) {
         return await next();
       }
-      let refs = queryRefs(model, req.query);
+      let refs = queryRefs(model, req.query, req.target);
       if (!this.options.deploy) {
         if (!this.localized(req.query, refs)) {
           return await next();
@@ -818,13 +818,18 @@ function baseRefs(model, refs) {
   const baseRefs = [];
   let currentRefs = refs;
   let nextRefs = [];
+  const visited = new Set();
   while (currentRefs.length > 0) {
     for (const ref of currentRefs) {
+      if (visited.has(ref)) {
+        continue;
+      }
+      visited.add(ref);
       const definition = model.definitions[ref];
       if (!definition.query) {
         baseRefs.push(ref);
       } else {
-        nextRefs = nextRefs.concat(queryRefs(model, definition.query));
+        nextRefs = nextRefs.concat(queryRefs(model, definition.query, definition));
       }
     }
     currentRefs = nextRefs;
@@ -853,49 +858,148 @@ function queryFromRefs(model, query) {
   return unique(selectFromRefs(model, query));
 }
 
-function queryRefs(model, query) {
+function queryRefs(model, query, definition) {
   if (!query.SELECT) {
     return [];
   }
-  return unique(selectRefs(model, query));
+  return unique(selectRefs(model, definition, query));
 }
 
 function selectFromRefs(model, query) {
   let refs = [];
-  if (query.SELECT.from.SELECT) {
-    refs = selectFromRefs(model, query.SELECT.from);
-  } else if (query.SELECT.from.ref) {
+  if (query.SELECT.from.ref) {
     refs = resolveRefs(model, query.SELECT.from.ref);
-  } else if ((query.SELECT.from.join || query.SELECT.from.SET) && query.SELECT.from.args) {
+  } else if (query.SELECT.from.args) {
     refs = query.SELECT.from.args.reduce((refs, arg) => {
-      refs = refs.concat(resolveRefs(model, arg.ref || arg));
+      if (arg.ref) {
+        refs = refs.concat(resolveRefs(model, arg.ref));
+      } else if (arg.args) {
+        refs = refs.concat(selectFromRefs(model, { SELECT: { from: { args: arg.args } } }));
+      }
       return refs;
     }, []);
+  } else if (query.SELECT.from.SELECT) {
+    refs = selectFromRefs(model, query.SELECT.from);
   }
   return refs;
 }
 
-function selectRefs(model, query) {
-  let refs = selectFromRefs(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));
+function selectFromPrimaryRef(model, query) {
+  if (query.SELECT.from.ref) {
+    return resolveRef(model, query.SELECT.from.ref);
+  } else if (query.SELECT.from.args) {
+    for (const arg of query.SELECT.from.args) {
+      if (arg.ref) {
+        return resolveRef(model, arg.ref);
+      } else if (arg.args) {
+        return selectFromPrimaryRef(model, { SELECT: { from: { args: arg.args } } });
+      }
     }
-    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));
+  } else if (query.SELECT.from.SELECT) {
+    return selectFromPrimaryRef(model, query.SELECT.from);
+  }
+}
+
+function selectFromAliases(model, definition, query) {
+  let aliases = {};
+  if (definition?.name) {
+    aliases["$self"] = definition.name;
+  }
+  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;
     }
-    if (query.SELECT.where) {
-      refs = refs.concat(expressionRefs(model, target, query.SELECT.where, query.SELECT.mixin));
+  } else if (query.SELECT.from.args) {
+    for (const arg of query.SELECT.from.args) {
+      if (arg.ref) {
+        const ref = resolveRef(model, arg.ref);
+        if (arg.as) {
+          aliases[arg.as] = ref;
+        } else {
+          const as = ref.split(".").pop();
+          aliases[as] = ref;
+        }
+      } else if (arg.args) {
+        for (const subArg of arg.args) {
+          aliases = {
+            ...aliases,
+            ...selectFromAliases(model, definition, { SELECT: { from: { args: subArg.args } } }),
+          };
+        }
+      }
     }
-    if (query.SELECT.having) {
-      refs = refs.concat(expressionRefs(model, target, query.SELECT.having, query.SELECT.mixin));
+  }
+  return aliases;
+}
+
+function selectOuterAliases(model, target, columns, mixins, aliases) {
+  const outerAliases = {};
+  if (columns) {
+    for (const column of columns) {
+      if (column.ref) {
+        const as = column.as || column.ref[column.ref.length - 1];
+        let current = target;
+        for (const ref of column.ref) {
+          const currentTarget = targetEntity(model, current, mixins, aliases, ref);
+          if (currentTarget != null) {
+            current = currentTarget;
+          }
+        }
+        outerAliases[as] = (current || target).name;
+      }
     }
   }
+  return outerAliases;
+}
+
+function selectRefs(model, definition, query, aliases) {
+  let targetName = selectFromPrimaryRef(model, query);
+  const target = targetName ? model.definitions[targetName] : undefined;
+  let refs = selectFromRefs(model, query);
+  aliases = {
+    ...aliases,
+    ...selectFromAliases(model, definition, query),
+  };
+  if (query.SELECT.columns) {
+    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, aliases));
+  }
+  const outerAliases = {
+    ...aliases,
+    ...selectOuterAliases(model, target, query.SELECT.columns, query.SELECT.mixin, aliases),
+  };
+  if (query.SELECT.having) {
+    refs = refs.concat(expressionRefs(model, target, query.SELECT.having, query.SELECT.mixin, outerAliases));
+  }
+  if (query.SELECT.orderBy) {
+    refs = refs.concat(expressionRefs(model, target, query.SELECT.orderBy, query.SELECT.mixin, outerAliases));
+  }
   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,49 +1021,55 @@ 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 = {};
+        if (current?.name !== definition?.name) {
           refs.push(current.name);
         }
+        if (ref.startsWith("$")) {
+          break;
+        }
+        current = targetEntity(model, current, currentMixins, aliases, ref);
+        currentMixins = {};
       }
     }
   }
   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));
+      refs = refs.concat(
+        selectRefs(model, undefined, expression, {
+          ...aliases,
+          ["$self"]: undefined,
+        }),
+      );
     }
   }
   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 = targetEntity(model, current, currentMixins, aliases, ref);
+        currentMixins = {};
         refs.push(current.name);
       }
       refs = refs.concat(expandRefs(model, current, column.expand));
@@ -968,6 +1078,26 @@ function expandRefs(model, definition, columns, mixin) {
   return refs;
 }
 
+function targetEntity(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]) {