@sap/eslint-plugin-cds 2.5.0 → 2.6.1

package/lib/rules/assoc2many-ambiguous-key.js

@@ -1,153 +1,154 @@
-const cds = require("@sap/cds");
+const cds = require('@sap/cds')
 
 /** @type {import('../types').Rule} */
 
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
       description:
-        "Ambiguous key with a `TO MANY` relationship since entries could appear multiple times with the same key.",
-      category: "Model Validation",
+        'Ambiguous key with a `TO MANY` relationship since entries could appear multiple times with the same key.',
+      category: 'Model Validation',
       recommended: true
     },
-    type: "problem",
-    model: "inferred"
+    type: 'problem',
+    model: 'inferred'
   },
-  create(context) {
-    return check_assoc2many_ambiguous_key;
+  create (context) {
+    return checkAssocs
 
-    function check_assoc2many_ambiguous_key() {
-      let csnOdata;
-      const m = context.getModel();
-      if (!m) return;
+    function checkAssocs () {
+      let csnOdata
+      const m = context.getModel()
+      if (!m) return
       if (m && m.definitions) {
-        csnOdata = cds.compile.for.odata(m);
-        const csnOdataLinked = cds.linked(csnOdata);
-        associationCardinalityFlaw(csnOdataLinked, context);
+        csnOdata = cds.compile.for.odata(m)
+        const csnOdataLinked = cds.linked(csnOdata)
+        associationCardinalityFlaw(csnOdataLinked, context)
       }
     }
   }
-};
+}
 
-function associationCardinalityFlaw(csn, context) {
+function associationCardinalityFlaw (csn, context) {
   processEntity(csn, (definition, sourceEntity, sourceAlias) => {
-    let refCardinalityMult = false;
-    let refPlainElement = false;
+    let refCardinalityMult = false
+    let refPlainElement = false
     processElement(
       csn,
       definition,
       sourceEntity,
       sourceAlias,
       () => {
-        refCardinalityMult = false;
-        refPlainElement = false;
+        refCardinalityMult = false
+        refPlainElement = false
       },
       (refEntity, refElement) => {
-        if (refElement.type === "cds.Association" || refElement.type === "cds.Composition") {
-          if (refElement.cardinality && refElement.cardinality.max === "*") {
-            refCardinalityMult = true;
+        if (refElement.type === 'cds.Association' || refElement.type === 'cds.Composition') {
+          if (refElement.cardinality && refElement.cardinality.max === '*') {
+            refCardinalityMult = true
           }
         } else {
-          refPlainElement = true;
+          refPlainElement = true
         }
       },
       (column) => {
         if (
           definition.keys &&
           Object.keys(definition.keys).length === 1 &&
-          Object.keys(definition.keys)[0] === "ID" &&
+          Object.keys(definition.keys)[0] === 'ID' &&
           refCardinalityMult &&
           refPlainElement
         ) {
-          const keyName = Object.keys(definition.keys)[0];
-          const key = definition.keys[keyName];
-          const keyLoc = context.getLocation(keyName, key, csn);
-          const colName = column.as ? column.as : column.name;
+          const keyName = Object.keys(definition.keys)[0]
+          const key = definition.keys[keyName]
+          const keyLoc = context.getLocation(keyName, key, csn)
+          const colName = column.as ? column.as : column.name
           context.report({
             message: `Ambiguous key in '${definition.name}'. Element '${colName}' leads to multiple entries so that key '${keyName}' is not unique.`,
             loc: keyLoc,
             file: key.$location.file
-          });
+          })
         }
       }
-    );
-  });
+    )
+  })
 }
 
-function processEntity(csn, eachCallback) {
+function processEntity (csn, eachCallback) {
   Object.keys(csn.definitions).forEach((name) => {
-    if (name.startsWith("localized.")) {
-      return;
+    if (name.startsWith('localized.')) {
+      return
     }
-    const definition = csn.definitions[name];
+    const definition = csn.definitions[name]
     if (
-      definition.kind === "entity" &&
+      definition.kind === 'entity' &&
       definition.query &&
       definition.query.SELECT &&
       definition.query.SELECT.columns
     ) {
-      let sourceEntity;
-      const sourceAlias = [];
+      let sourceEntity
+      const sourceAlias = []
       if (definition.query.SELECT.from.ref) {
         // From
-        sourceEntity = csn.definitions[definition.query.SELECT.from.ref.join("_")];
+        sourceEntity = csn.definitions[definition.query.SELECT.from.ref.join('_')]
         sourceAlias.push({
           from: sourceEntity.name,
-          as: definition.query.SELECT.from.as || definition.query.SELECT.from.ref.slice(-1)[0].split(".").pop()
-        });
+          as: definition.query.SELECT.from.as || definition.query.SELECT.from.ref.slice(-1)[0].split('.').pop()
+        })
       } else if (definition.query.SELECT.from.args && definition.query.SELECT.from.args[0].ref) {
         // Join
-        sourceEntity = csn.definitions[definition.query.SELECT.from.args[0].ref.join("_")];
+        sourceEntity = csn.definitions[definition.query.SELECT.from.args[0].ref.join('_')]
         definition.query.SELECT.from.args.forEach((arg) => {
           sourceAlias.push({
-            from: arg.ref.join("_"),
-            as: arg.as || arg.ref.slice(-1)[0].split(".").pop()
-          });
-        });
+            from: arg.ref.join('_'),
+            as: arg.as || arg.ref.slice(-1)[0].split('.').pop()
+          })
+        })
       }
       if (!sourceEntity) {
-        return;
+        return
       }
-      eachCallback(definition, sourceEntity, sourceAlias);
+      eachCallback(definition, sourceEntity, sourceAlias)
     }
-  });
+  })
 }
 
-function processElement(csn, definition, sourceEntity, sourceAlias, beforeCallback, eachCallback, afterCallback) {
+function processElement (csn, definition, sourceEntity, sourceAlias, beforeCallback, eachCallback, afterCallback) {
   definition.query.SELECT.columns.forEach((column) => {
     if (column.ref && column.ref.length > 1) {
-      let refEntity = sourceEntity;
-      let refAlias = sourceAlias;
-      beforeCallback();
+      let refEntity = sourceEntity
+      let refAlias = sourceAlias
+      beforeCallback()
       column.ref.forEach((ref) => {
-        ref = ref.id || ref;
+        ref = ref.id || ref
         // Alias
         const matchAlias = refAlias.find((alias) => {
-          return alias.as === ref;
-        });
-        let refElement;
+          return alias.as === ref
+        })
+        let refElement
         if (matchAlias) {
-          refEntity = csn.definitions[matchAlias.from];
+          refEntity = csn.definitions[matchAlias.from]
         } else {
-          refElement = refEntity.elements[ref];
+          refElement = refEntity.elements[ref]
           // Mixin
           if (!refElement) {
-            refElement = definition.elements[ref];
+            refElement = definition.elements[ref]
             if (!refElement && definition.query.SELECT.mixin) {
-              refElement = definition.query.SELECT.mixin[ref];
+              refElement = definition.query.SELECT.mixin[ref]
               if (!refElement && definition.query.SELECT.mixin[column.ref[0]]) {
-                refElement = definition.query.SELECT.mixin[column.ref[0]]._target.elements[ref];
+                refElement = definition.query.SELECT.mixin[column.ref[0]]._target.elements[ref]
               }
             }
           }
-          eachCallback(refEntity, refElement);
-          if (refElement.type === "cds.Association" || refElement.type === "cds.Composition") {
-            refEntity = csn.definitions[refElement.target];
+          eachCallback(refEntity, refElement)
+          if (refElement.type === 'cds.Association' || refElement.type === 'cds.Composition') {
+            refEntity = csn.definitions[refElement.target]
           }
         }
-        refAlias = [];
-      });
-      afterCallback(column);
+        refAlias = []
+      })
+      afterCallback(column)
     }
-  });
+  })
 }

package/lib/rules/auth-no-empty-restrictions.js

@@ -1,37 +1,38 @@
-const LABELS = ["@restrict", "@requires"];
+const LABELS = ['@restrict', '@requires']
 
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: "`@restrict` and `@requires` must not be empty.",
-      category: "Model Validation",
+      description: '`@restrict` and `@requires` must not be empty.',
+      category: 'Model Validation',
       recommended: true
     },
     hasSuggestions: true,
     messages: {
-      InvalidItem: `Invalid item '{{invalid}}'. Did you mean '{{candidates}}'?`,
-      ReplaceItemWith: `Replace '{{invalid}}' with '{{candidates}}'`
+      InvalidItem: "Invalid item '{{invalid}}'. Did you mean '{{candidates}}'?",
+      ReplaceItemWith: "Replace '{{invalid}}' with '{{candidates}}'"
     },
-    type: "problem",
-    model: "inferred"
+    type: 'problem',
+    model: 'inferred'
   },
-  create(context) {
+  create (context) {
     return {
-      entity: check_restrictions,
-      service: check_restrictions
-    };
+      entity: checkRestrictions,
+      service: checkRestrictions
+    }
 
-    function check_restrictions(e) {
+    function checkRestrictions (e) {
       for (const l of LABELS) {
-        const invalid = (typeof e[l] === "object" && e[l].length === 0) || (typeof e[l] === "string" && e[l] === "");
+        const invalid = (typeof e[l] === 'object' && e[l].length === 0) || (typeof e[l] === 'string' && e[l] === '')
         if (invalid) {
           context.report({
             message: `No explicit restrictions provided on ${e.kind} \`${e.name}\` at \`${l}\`.`,
             node: context.getNode(e),
             file: e.$location.file
-          });
+          })
         }
       }
     }
   }
-};
+}

package/lib/rules/auth-use-requires.js

@@ -1,38 +1,39 @@
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: "Use `@requires` instead of `@restrict.to` in actions and services with unrestricted events.",
-      category: "Model Validation",
+      description: 'Use `@requires` instead of `@restrict.to` in actions and services with unrestricted events.',
+      category: 'Model Validation',
       recommended: true,
-      version: "2.4.1"
+      version: '2.4.1'
     },
     hasSuggestions: true,
     messages: {
-      InvalidItem: `Invalid item '{{invalid}}'. Did you mean '{{candidates}}'?`,
-      ReplaceItemWith: `Replace '{{invalid}}' with '{{candidates}}'`
+      InvalidItem: "Invalid item '{{invalid}}'. Did you mean '{{candidates}}'?",
+      ReplaceItemWith: "Replace '{{invalid}}' with '{{candidates}}'"
     },
-    type: "problem",
-    model: "inferred"
+    type: 'problem',
+    model: 'inferred'
   },
-  create(context) {
+  create (context) {
     return {
-      service: check_restrict,
-      action: check_restrict
-    };
+      service: checkRestrict,
+      action: checkRestrict
+    }
 
-    function check_restrict(e) {
-      if (e && e["@restrict"] && typeof e["@restrict"] === "object") {
-        for (const entry of e["@restrict"]) {
-          const keys = Object.keys(entry);
-          if (keys.includes("to") && keys.includes("grant") && entry.grant === "*") {
+    function checkRestrict (e) {
+      if (e && e['@restrict'] && typeof e['@restrict'] === 'object') {
+        for (const entry of e['@restrict']) {
+          const keys = Object.keys(entry)
+          if (keys.includes('to') && keys.includes('grant') && entry.grant === '*') {
             context.report({
               message: `Use \`@requires\` instead of \`@restrict.to\` at ${e.kind} \`${e.name}\`.`,
               node: context.getNode(e),
               file: e.$location.file
-            });
+            })
           }
         }
       }
     }
   }
-};
+}

package/lib/rules/auth-valid-restrict-grant.js

@@ -1,105 +1,108 @@
-const { findFuzzy, isEmptyString, isEmptyObject, isStringInArray } = require("../utils/rules");
+const { findFuzzy, isEmptyString, isEmptyObject, isStringInArray } = require('../utils/rules')
 
-const REPLACE_AS_WRITE_EVENTS = ["READ", "CREATE", "UPDATE", "DELETE"];
-const VALID_EVENTS = REPLACE_AS_WRITE_EVENTS.concat(["INSERT", "UPSERT", "WRITE", "*"]);
+const REPLACE_AS_WRITE_EVENTS = ['READ', 'CREATE', 'UPDATE', 'DELETE']
+const VALID_EVENTS = REPLACE_AS_WRITE_EVENTS.concat(['INSERT', 'UPSERT', 'WRITE', '*'])
 
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: "`@restrict.grant` must have valid values.",
-      category: "Model Validation",
+      description: '`@restrict.grant` must have valid values.',
+      category: 'Model Validation',
       recommended: true
     },
     messages: {
-      InvalidItem: `Invalid item '{{invalid}}'. Did you mean '{{candidates}}'?`,
-      ReplaceItemWith: `Replace '{{invalid}}' with '{{candidates}}'`
+      InvalidItem: "Invalid item '{{invalid}}'. Did you mean '{{candidates}}'?",
+      ReplaceItemWith: "Replace '{{invalid}}' with '{{candidates}}'"
     },
-    type: "problem",
-    model: "inferred"
+    type: 'problem',
+    model: 'inferred'
   },
-  create(context) {
+  create (context) {
     return {
-      entity: check_restrict_grant
-    };
+      entity: checkRestrictGrant
+    }
 
-    function check_restrict_grant(e) {
-      const node = context.getNode(e);
-      const file = e.$location.file;
-      if (e["@restrict"]) {
-        const actions = e.actions;
-        const actionNames = actions ? Object.keys(actions).map((s) => actions[s].name) : [];
-        const validEventsAndActions = VALID_EVENTS.concat(actionNames);
+    function checkRestrictGrant (e) {
+      const node = context.getNode(e)
+      const file = e.$location.file
+      if (e['@restrict']) {
+        const actions = e.actions
+        const actionNames = actions ? Object.keys(actions).map((s) => actions[s].name) : []
+        const validEventsAndActions = VALID_EVENTS.concat(actionNames)
 
-        for (const entry of e["@restrict"]) {
-          if (Object.keys(entry).includes("grant")) {
-            const grantValue = entry.grant;
+        for (const entry of e['@restrict']) {
+          if (Object.keys(entry).includes('grant')) {
+            const grantValue = entry.grant
             switch (typeof grantValue) {
-              case "string": {
+              case 'string': {
                 if (isEmptyString(grantValue)) {
                   context.report({
                     message: `Missing event/action on ${e.name} for \`@restrict.grant\`.`,
                     node,
                     file
-                  });
+                  })
                 } else {
                   if (!isStringInArray(grantValue, validEventsAndActions, true)) {
-                    const candidates = findFuzzy(grantValue, validEventsAndActions.sort());
+                    const candidates = findFuzzy(grantValue, validEventsAndActions.sort())
                     context.report({
-                      messageId: "InvalidItem",
+                      messageId: 'InvalidItem',
                       data: { invalid: grantValue, candidates },
                       node,
                       file
-                    });
+                    })
                   }
                 }
-                break;
+                break
               }
 
-              case "object":
+              case 'object':
                 if (isEmptyObject(grantValue)) {
                   context.report({
                     message: `Missing event/action on ${e.name} for \`@restrict.grant\`.`,
                     node,
                     file
-                  });
+                  })
                 } else {
-                  let valuesForWrite = grantValue.filter(function (item) {
-                    return item !== "READ" && item !== "WRITE" && item !== "*";
-                  });
+                  const valuesForWrite = grantValue.filter(function (item) {
+                    return item !== 'READ' && item !== 'WRITE' && item !== '*'
+                  })
                   for (const value of grantValue) {
                     if (!validEventsAndActions.includes(value)) {
-                      const candidates = findFuzzy(value, validEventsAndActions.sort());
+                      const candidates = findFuzzy(value, validEventsAndActions.sort())
                       context.report({
-                        messageId: "InvalidItem",
+                        messageId: 'InvalidItem',
                         data: { invalid: value, candidates },
                         node,
                         file
-                      });
+                      })
                     }
                   }
-                  let allValuesIncluded = grantValue.every((v) => valuesForWrite.includes(v));
+                  // If values do not contain 'READ, WRITE, *', 'WRITE' only is enough
+                  const allValuesIncluded = grantValue.every((v) => valuesForWrite.includes(v))
                   if (allValuesIncluded) {
                     context.report({
-                      messageId: "InvalidItem",
-                      data: { invalid: [`[${grantValue}]`], candidates: [`["WRITE"]`] },
+                      messageId: 'InvalidItem',
+                      data: { invalid: [`[${grantValue}]`], candidates: ['["WRITE"]'] },
                       node,
                       file
-                    });
+                    })
                   }
-                  if (grantValue.includes("*")) {
+                  // If values contain '*', '*' only is enough
+                  if (grantValue.length > 1 && grantValue.includes('*')) {
                     context.report({
-                      messageId: "InvalidItem",
-                      data: { invalid: `[${grantValue}]`, candidates: [`["*"]`] },
+                      messageId: 'InvalidItem',
+                      data: { invalid: `[${grantValue}]`, candidates: ['["*"]'] },
                       node,
                       file
-                    });
+                    })
                   }
                 }
-                break;
+                break
             }
           }
         }
       }
     }
   }
-};
+}

package/lib/rules/auth-valid-restrict-keys.js

@@ -1,38 +1,39 @@
-const { isEmptyObject, findFuzzy } = require("../utils/rules");
+const { isEmptyObject, findFuzzy } = require('../utils/rules')
 
-const VALID_RESTRICT_KEYS = ["grant", "to", "where"];
+const VALID_RESTRICT_KEYS = ['grant', 'to', 'where']
 
 module.exports = {
   meta: {
+    schema: [{/* to avoid deprecation warning for ESLint 9 */}],
     docs: {
-      description: "`@restrict` must have properly spelled `to`, `grant`, and `where` keys.",
-      category: "Model Validation",
+      description: '`@restrict` must have properly spelled `to`, `grant`, and `where` keys.',
+      category: 'Model Validation',
       recommended: true
     },
     messages: {
-      InvalidItem: `Misspelled key '{{invalid}}'. Did you mean '{{candidates}}'?`
+      InvalidItem: "Misspelled key '{{invalid}}'. Did you mean '{{candidates}}'?"
     },
-    type: "problem",
-    model: "inferred"
+    type: 'problem',
+    model: 'inferred'
   },
-  create(context) {
+  create (context) {
     return {
-      entity: check_restrict_keys
-    };
+      entity: checkRestrictKeys
+    }
 
-    function check_restrict_keys(e) {
-      if (e["@restrict"]) {
-        for (const entry of e["@restrict"]) {
-          if (typeof entry === "object" && !isEmptyObject(entry)) {
+    function checkRestrictKeys (e) {
+      if (e['@restrict']) {
+        for (const entry of e['@restrict']) {
+          if (typeof entry === 'object' && !isEmptyObject(entry)) {
             for (const key of Object.keys(entry)) {
               if (!VALID_RESTRICT_KEYS.includes(key)) {
-                const candidates = findFuzzy(key, VALID_RESTRICT_KEYS.sort());
+                const candidates = findFuzzy(key, VALID_RESTRICT_KEYS.sort())
                 context.report({
-                  messageId: "InvalidItem",
+                  messageId: 'InvalidItem',
                   data: { invalid: key, candidates },
                   node: context.getNode(e),
                   file: e.$location.file
-                });
+                })
               }
             }
           }
@@ -40,4 +41,4 @@ module.exports = {
       }
     }
   }
-};
+}