@cap-js-community/common 0.2.0 → 0.2.2

package/README.md

@@ -41,13 +41,14 @@ entity Books {
 
 ### Annotations
 
-Annotations can be used to enable replication cache for a service:
+Annotations can be used to enable replication cache for a service on entity level:
 
 - `@cds.replicate: Boolean | Object`: Enable replication cache for entity
   - `@cds.replicate.ttl: Number`: Time-To-Live (TTL) of cache entry in milliseconds
   - `@cds.replicate.auto: Boolean`: Replication is managed automatically
   - `@cds.replicate.preload: Boolean`: Preload replication for entity
   - `@cds.replicate.group: String`: Replication group name
+  - `@cds.replicate.static: Boolean`: Statically replicate non-tenant aware
 
 Defaults are taken from CDS environment.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js-community/common",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "CAP Node.js Community Common",
   "homepage": "https://cap.cloud.sap/",
   "engines": {
@@ -51,18 +51,18 @@
   },
   "devDependencies": {
     "@cap-js-community/common": "./",
-    "@cap-js/cds-test": "^0.3.0",
-    "@sap/cds": "^9.0.2",
+    "@cap-js/cds-test": "^0.4.0",
+    "@sap/cds": "^9.0.4",
     "@sap/cds-common-content": "^3.0.1",
-    "@sap/cds-dk": "^9.0.4",
-    "eslint": "9.28.0",
+    "@sap/cds-dk": "^9.0.5",
+    "eslint": "9.29.0",
     "eslint-config-prettier": "10.1.5",
-    "eslint-plugin-jest": "28.12.0",
-    "eslint-plugin-n": "^17.19.0",
-    "jest": "29.7.0",
+    "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.5.3",
+    "prettier": "3.6.1",
     "shelljs": "^0.10.0"
   },
   "cds": {

package/src/replication-cache/ReplicationCache.js

@@ -28,6 +28,7 @@ const Status = {
 
 const Annotations = {
   Replicate: "@cds.replicate",
+  ReplicateStatic: "@cds.replicate.static",
   ReplicateGroup: "@cds.replicate.group",
   ReplicateAuto: "@cds.replicate.auto",
   ReplicateTTL: "@cds.replicate.ttl",
@@ -61,7 +62,7 @@ class ReplicationCache {
     });
     cds.on("connect", (service) => {
       if (service.name === this.name) {
-        const refs = ReplicationCache.replicationRefs(this.model, service);
+        const refs = ReplicationCache.replicationRefs(this.model, service, this.options.deploy);
         if (refs.length > 0) {
           this.setup(service, refs);
           this.log.info("using replication cache", {
@@ -82,12 +83,12 @@ class ReplicationCache {
     });
   }
 
-  static replicationRefs(model, service) {
+  static replicationRefs(model, service, deploy) {
     const refs = Object.keys(model.definitions).filter((name) => {
       const definition = model.definitions[name];
       return (
         definition.kind === "entity" &&
-        !definition.projection &&
+        (!(definition.query || definition.projection) || !deploy) &&
         (service.name === "db" || name.startsWith(`${service.name}.`)) &&
         Object.values(Annotations).find((annotation) => {
           return definition[annotation] !== undefined;
@@ -169,6 +170,14 @@ class ReplicationCache {
       if (!this.options.search && !this.search(req.query)) {
         return await next();
       }
+      let fromRefs = queryFromRefs(model, req.query);
+      if (this.options.deploy) {
+        fromRefs = baseRefs(model, fromRefs);
+        fromRefs = localizedRefs(model, req.query, fromRefs);
+      }
+      if (fromRefs.length === 0 || !this.relevant(fromRefs)) {
+        return await next();
+      }
       let refs = queryRefs(model, req.query);
       if (!this.options.deploy) {
         if (!this.localized(req.query, refs)) {
@@ -189,8 +198,12 @@ class ReplicationCache {
         this.stats.counts[ref] ??= 0;
         this.stats.counts[ref]++;
       }
+      let tenant = req.tenant;
+      if (staticRefs(model, refs)) {
+        tenant = undefined; // non-tenant cache
+      }
       const status = await this.load(
-        req.tenant,
+        tenant,
         refs,
         {
           auto: this.options.auto,
@@ -203,7 +216,7 @@ class ReplicationCache {
         this.stats.used++;
         this.stats.ratio = Math.round(this.stats.used / this.stats.hits);
         this.log.debug("Replication cache was used");
-        const db = this.cache.get(req.tenant).db;
+        const db = this.cache.get(tenant).db;
         if (this.options.measure) {
           return this.measure(
             async () => {
@@ -530,7 +543,7 @@ class ReplicationCache {
     let projections = true;
     for (const ref of refs) {
       const definition = model.definitions[ref];
-      if (definition.query) {
+      if (definition.query || definition.projection) {
         this.stats.projections[ref] ??= 0;
         this.stats.projections[ref]++;
         this.log.debug("Replication cache not enabled for 'projections' without deploy feature", {
@@ -833,17 +846,24 @@ function localizedRefs(model, query, refs) {
   return unique(refs.concat(localizedRefs));
 }
 
+function queryFromRefs(model, query) {
+  if (!query.SELECT) {
+    return [];
+  }
+  return unique(selectFromRefs(model, query));
+}
+
 function queryRefs(model, query) {
   if (!query.SELECT) {
     return [];
   }
-  return unique(fromRefs(model, query));
+  return unique(selectRefs(model, query));
 }
 
-function fromRefs(model, query) {
+function selectFromRefs(model, query) {
   let refs = [];
   if (query.SELECT.from.SELECT) {
-    refs = fromRefs(model, query.SELECT.from);
+    refs = selectFromRefs(model, query.SELECT.from);
   } else 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) {
@@ -852,25 +872,71 @@ function fromRefs(model, query) {
       return refs;
     }, []);
   }
+  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));
+      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));
-      refs = refs.concat(expandRefs(model, target, 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));
+      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));
+      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];
@@ -892,14 +958,16 @@ function resolveRefs(model, refs) {
   return resolvedRefs;
 }
 
-function identifierRefs(model, definition, array) {
+function identifierRefs(model, definition, expressions, mixins, aliases) {
   let refs = [];
-  for (const entry of array) {
-    if (Array.isArray(entry.ref)) {
+  for (const expression of expressions) {
+    if (Array.isArray(expression.ref)) {
       let current = definition;
-      for (const ref of entry.ref) {
-        if (current.elements[ref].type === "cds.Association" || current.elements[ref].type === "cds.Composition") {
-          current = current.elements[ref]._target;
+      let currentMixins = mixins;
+      for (const ref of expression.ref) {
+        current = target(model, current, currentMixins, aliases, ref);
+        if (current !== null) {
+          currentMixins = {};
           refs.push(current.name);
         }
       }
@@ -908,27 +976,29 @@ function identifierRefs(model, definition, array) {
   return refs;
 }
 
-function expressionRefs(model, definition, array) {
-  let refs = identifierRefs(model, definition, array);
-  for (const entry of array) {
-    if (entry.xpr) {
-      refs = refs.concat(expressionRefs(model, definition, entry.xpr));
-    } else if (entry.args) {
-      refs = refs.concat(expressionRefs(model, definition, entry.args));
-    } else if (entry.SELECT) {
-      refs = refs.concat(fromRefs(model, entry));
+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, mixins, aliases));
+    } else if (expression.args) {
+      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) {
+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 currentMixins = mixins;
       for (const ref of column.ref) {
-        current = current.elements[ref]._target;
+        current = target(model, current, currentMixins, aliases, ref);
+        currentMixins = {};
         refs.push(current.name);
       }
       refs = refs.concat(expandRefs(model, current, column.expand));
@@ -937,6 +1007,35 @@ function expandRefs(model, definition, columns) {
   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]) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function cached(cache, field, init) {
   try {
     if (init && !cache.get(field)) {