@cedarjs/eslint-plugin 8.0.0-canary.3546 → 8.0.0-canary.3548

package/dist/index.d.ts

@@ -8,6 +8,9 @@ export declare const rules: {
     'process-env-computed': ESLintUtils.RuleModule<"unexpected", [], unknown, ESLintUtils.RuleListener>;
     'service-type-annotations': ESLintUtils.RuleModule<"needsType", [], unknown, ESLintUtils.RuleListener>;
     'unsupported-route-components': ESLintUtils.RuleModule<"unexpected", [], unknown, ESLintUtils.RuleListener>;
+    'valid-permission-names': ESLintUtils.RuleModule<"unknownPermission" | "unknownPermissionWithSuggestion", [({
+        permissionsFile?: string;
+    } | undefined)?], unknown, ESLintUtils.RuleListener>;
 };
 declare const plugin: {
     meta: {
@@ -19,6 +22,9 @@ declare const plugin: {
         'process-env-computed': ESLintUtils.RuleModule<"unexpected", [], unknown, ESLintUtils.RuleListener>;
         'service-type-annotations': ESLintUtils.RuleModule<"needsType", [], unknown, ESLintUtils.RuleListener>;
         'unsupported-route-components': ESLintUtils.RuleModule<"unexpected", [], unknown, ESLintUtils.RuleListener>;
+        'valid-permission-names': ESLintUtils.RuleModule<"unknownPermission" | "unknownPermissionWithSuggestion", [({
+            permissionsFile?: string;
+        } | undefined)?], unknown, ESLintUtils.RuleListener>;
     };
 };
 export default plugin;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAS3D,eAAO,MAAM,IAAI;;;CAGhB,CAAA;AAED,eAAO,MAAM,KAAK;;;;;CAKwC,CAAA;AAE1D,QAAA,MAAM,MAAM;;;;;;;;;;;CAAkB,CAAA;AAE9B,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAA;AAU3D,eAAO,MAAM,IAAI;;;CAGhB,CAAA;AAED,eAAO,MAAM,KAAK;;;;;;;;CAM4D,CAAA;AAE9E,QAAA,MAAM,MAAM;;;;;;;;;;;;;;CAAkB,CAAA;AAE9B,eAAe,MAAM,CAAA"}

package/dist/index.js

@@ -3,6 +3,7 @@ import { cellTypeAnnotations } from "./cell-type-annotations.js";
 import { processEnvComputedRule } from "./process-env-computed.js";
 import { serviceTypeAnnotations } from "./service-type-annotations.js";
 import { unsupportedRouteComponents } from "./unsupported-route-components.js";
+import { validPermissionNames } from "./valid-permission-names.js";
 const meta = {
   name: "@cedarjs/eslint-plugin",
   version: pkgJson.version
@@ -11,7 +12,8 @@ const rules = {
   "cell-type-annotations": cellTypeAnnotations,
   "process-env-computed": processEnvComputedRule,
   "service-type-annotations": serviceTypeAnnotations,
-  "unsupported-route-components": unsupportedRouteComponents
+  "unsupported-route-components": unsupportedRouteComponents,
+  "valid-permission-names": validPermissionNames
 };
 const plugin = { meta, rules };
 var index_default = plugin;

package/dist/valid-permission-names.d.ts

@@ -0,0 +1,26 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import type { DirectiveNode, StringValueNode } from 'graphql';
+export type UnknownPermission = {
+    /** The directive's `permission` argument */
+    node: StringValueNode;
+    name: string;
+    /** The closest defined name, when one is close enough to be a typo */
+    suggestion: string | undefined;
+};
+/**
+ * What's wrong with `directive`, or `undefined` when it isn't a
+ * `@requirePermission` whose `permission` is a literal that `names` doesn't
+ * have
+ */
+export declare function checkRequirePermission(directive: DirectiveNode, names: ReadonlySet<string>): UnknownPermission | undefined;
+/**
+ * The names in the `permissions: [...]` array of the first
+ * `definePermissions({ ... })` call in `source`, or `null` when there's no
+ * such call or the array holds anything but string literals (we can't tell
+ * what the names are then)
+ */
+export declare function parsePermissionNames(source: string): Set<string> | null;
+export declare const validPermissionNames: ESLintUtils.RuleModule<"unknownPermission" | "unknownPermissionWithSuggestion", [({
+    permissionsFile?: string;
+} | undefined)?], unknown, ESLintUtils.RuleListener>;
+//# sourceMappingURL=valid-permission-names.d.ts.map

package/dist/valid-permission-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valid-permission-names.d.ts","sourceRoot":"","sources":["../src/valid-permission-names.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,WAAW,EAAkB,MAAM,0BAA0B,CAAA;AAEtE,OAAO,KAAK,EAAE,aAAa,EAAgB,eAAe,EAAE,MAAM,SAAS,CAAA;AAkB3E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,4CAA4C;IAC5C,IAAI,EAAE,eAAe,CAAA;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,sEAAsE;IACtE,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAC/B,CAAA;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,iBAAiB,GAAG,SAAS,CAqB/B;AAiFD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAiEvE;AA0FD,eAAO,MAAM,oBAAoB;sBACV,MAAM;oDAsG3B,CAAA"}

package/dist/valid-permission-names.js

@@ -0,0 +1,245 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  simpleTraverse,
+  parse as parseTypeScript
+} from "@typescript-eslint/typescript-estree";
+import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { Kind, parse as parseGraphQL, visit } from "graphql";
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+const PERMISSIONS_FILE = path.join("packages", "permissions", "src", "index.ts");
+const SDL_FILE = /\.sdl\.(?:ts|js)$/;
+function checkRequirePermission(directive, names) {
+  if (directive.name.value !== "requirePermission") {
+    return void 0;
+  }
+  const argument = directive.arguments?.find(
+    (argument2) => argument2.name.value === "permission"
+  );
+  if (argument?.value.kind !== Kind.STRING) {
+    return void 0;
+  }
+  const name = argument.value.value;
+  if (names.has(name)) {
+    return void 0;
+  }
+  return { node: argument.value, name, suggestion: closestName(name, names) };
+}
+function templateText(template, source) {
+  const start = template.range[0] + 1;
+  let text = "";
+  let cursor = start;
+  for (const quasi of template.quasis) {
+    const rawStart = quasi.range[0] + 1;
+    const rawEnd = quasi.range[1] - (quasi.tail ? 1 : 2);
+    text += source.slice(cursor, rawStart).replace(/[^\n]/g, " ");
+    text += source.slice(rawStart, rawEnd);
+    cursor = rawEnd;
+  }
+  return { start, text };
+}
+const cache = /* @__PURE__ */ new Map();
+function unwrapTypeExpressions(node) {
+  let current = node;
+  while (current.type === AST_NODE_TYPES.TSAsExpression || current.type === AST_NODE_TYPES.TSSatisfiesExpression || current.type === AST_NODE_TYPES.TSNonNullExpression) {
+    current = current.expression;
+  }
+  return current;
+}
+function stringValue(node) {
+  if (node.type === AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 && node.quasis.length === 1) {
+    return node.quasis[0].value.cooked ?? void 0;
+  }
+  return void 0;
+}
+function propertyName(property) {
+  if (property.computed) {
+    return void 0;
+  }
+  if (property.key.type === AST_NODE_TYPES.Identifier) {
+    return property.key.name;
+  }
+  return stringValue(property.key);
+}
+function parsePermissionNames(source) {
+  let ast;
+  try {
+    ast = parseTypeScript(source, { jsx: false, range: false, loc: false });
+  } catch {
+    return null;
+  }
+  const result = { names: null };
+  let found = false;
+  simpleTraverse(ast, {
+    enter(node) {
+      if (found || node.type !== AST_NODE_TYPES.CallExpression || node.callee.type !== AST_NODE_TYPES.Identifier || node.callee.name !== "definePermissions") {
+        return;
+      }
+      found = true;
+      const options = node.arguments[0];
+      if (options?.type !== AST_NODE_TYPES.ObjectExpression) {
+        return;
+      }
+      for (const property of options.properties) {
+        if (property.type !== AST_NODE_TYPES.Property || propertyName(property) !== "permissions") {
+          continue;
+        }
+        const value = unwrapTypeExpressions(property.value);
+        if (value.type !== AST_NODE_TYPES.ArrayExpression) {
+          continue;
+        }
+        const names = /* @__PURE__ */ new Set();
+        for (const element of value.elements) {
+          const name = element ? stringValue(unwrapTypeExpressions(element)) : void 0;
+          if (name === void 0) {
+            return;
+          }
+          names.add(name);
+        }
+        result.names = names;
+      }
+    }
+  });
+  return result.names;
+}
+function readPermissionNames(file) {
+  let mtimeMs;
+  try {
+    mtimeMs = fs.statSync(file).mtimeMs;
+  } catch {
+    cache.delete(file);
+    return null;
+  }
+  const cached = cache.get(file);
+  if (cached?.mtimeMs === mtimeMs) {
+    return cached.names;
+  }
+  let names = null;
+  try {
+    names = parsePermissionNames(fs.readFileSync(file, "utf-8"));
+  } catch {
+    names = null;
+  }
+  cache.set(file, { mtimeMs, names });
+  return names;
+}
+function findPermissionsFile(dir) {
+  for (let current = dir; ; ) {
+    const candidate = path.join(current, PERMISSIONS_FILE);
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      row[j] = Math.min(
+        previous[j] + 1,
+        row[j - 1] + 1,
+        previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1)
+      );
+    }
+    previous = row;
+  }
+  return previous[b.length];
+}
+function closestName(name, names) {
+  const maxDistance = Math.max(2, Math.floor(name.length / 4));
+  let best;
+  for (const candidate of names) {
+    const distance = editDistance(name, candidate);
+    if (distance <= maxDistance && (!best || distance < best.distance)) {
+      best = { name: candidate, distance };
+    }
+  }
+  return best?.name;
+}
+const validPermissionNames = createRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Check that the permissions named in an SDL file's @requirePermission directives are defined"
+    },
+    messages: {
+      unknownPermission: 'Unknown permission "{{name}}". Add it to `permissions` in definePermissions(), or fix the name.',
+      unknownPermissionWithSuggestion: 'Unknown permission "{{name}}". Did you mean "{{suggestion}}"?'
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          permissionsFile: { type: "string" }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    if (!SDL_FILE.test(context.filename)) {
+      return {};
+    }
+    const permissionsFile = options.permissionsFile ? path.resolve(context.cwd, options.permissionsFile) : findPermissionsFile(path.dirname(context.filename));
+    const names = permissionsFile ? readPermissionNames(permissionsFile) : null;
+    if (!names) {
+      return {};
+    }
+    const { sourceCode } = context;
+    return {
+      TaggedTemplateExpression(node) {
+        if (node.tag.type !== AST_NODE_TYPES.Identifier || node.tag.name !== "gql") {
+          return;
+        }
+        const { start, text } = templateText(node.quasi, sourceCode.text);
+        let document;
+        try {
+          document = parseGraphQL(text);
+        } catch {
+          return;
+        }
+        visit(document, {
+          Directive(directive) {
+            const unknown = checkRequirePermission(directive, names);
+            if (!unknown?.node.loc) {
+              return;
+            }
+            const { name, suggestion } = unknown;
+            const { loc } = unknown.node;
+            if (sourceCode.text.slice(start + loc.start, start + loc.end) !== text.slice(loc.start, loc.end)) {
+              return;
+            }
+            context.report({
+              loc: {
+                start: sourceCode.getLocFromIndex(start + loc.start),
+                end: sourceCode.getLocFromIndex(start + loc.end)
+              },
+              ...suggestion ? {
+                messageId: "unknownPermissionWithSuggestion",
+                data: { name, suggestion }
+              } : {
+                messageId: "unknownPermission",
+                data: { name }
+              }
+            });
+          }
+        });
+      }
+    };
+  }
+});
+export {
+  checkRequirePermission,
+  parsePermissionNames,
+  validPermissionNames
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/eslint-plugin",
-  "version": "8.0.0-canary.3546",
+  "version": "8.0.0-canary.3548",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
@@ -23,15 +23,18 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
+    "@typescript-eslint/typescript-estree": "8.72.0",
     "@typescript-eslint/utils": "8.72.0",
-    "eslint": "8.57.1"
+    "eslint": "8.57.1",
+    "graphql": "16.14.2"
   },
   "devDependencies": {
-    "@cedarjs/framework-tools": "8.0.0-canary.3546",
+    "@cedarjs/framework-tools": "8.0.0-canary.3548",
     "@types/eslint": "8.56.12",
     "@types/estree": "1.0.9",
     "@typescript-eslint/parser": "8.72.0",
     "@typescript-eslint/rule-tester": "8.72.0",
+    "ts-dedent": "2.3.0",
     "typescript": "5.9.3",
     "vitest": "4.1.12"
   },