@cedarjs/eslint-plugin 6.0.0-rc.312 → 6.0.0

package/dist/cell-type-annotations.d.ts

@@ -0,0 +1,3 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+export declare const cellTypeAnnotations: TSESLint.RuleModule<"needsTypeAnnotation" | "beforeQueryParamNeedsType", [], unknown, TSESLint.RuleListener>;
+//# sourceMappingURL=cell-type-annotations.d.ts.map

package/dist/cell-type-annotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-type-annotations.d.ts","sourceRoot":"","sources":["../src/cell-type-annotations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,0BAA0B,CAAA;AAwHlE,eAAO,MAAM,mBAAmB,8GAiZ9B,CAAA"}

package/dist/cell-type-annotations.js

@@ -0,0 +1,348 @@
+import { basename } from "node:path";
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+const LIFECYCLE_EXPORTS = /* @__PURE__ */ new Set(["beforeQuery", "afterQuery", "isEmpty"]);
+const RENDER_PROP_EXPORTS = /* @__PURE__ */ new Set(["Loading", "Failure", "Success"]);
+function getParamPattern(param) {
+  return param.type === AST_NODE_TYPES.AssignmentPattern ? param.left : param;
+}
+function paramHasTypeAnnotation(param) {
+  const pattern = getParamPattern(param);
+  return "typeAnnotation" in pattern && !!pattern.typeAnnotation;
+}
+function getParamsClosingParen(sourceCode, fn) {
+  if (fn.params.length > 0) {
+    const lastParam = fn.params[fn.params.length - 1];
+    return sourceCode.getTokenAfter(lastParam, (token) => token.value === ")");
+  }
+  return sourceCode.getFirstToken(fn, (token) => token.value === ")");
+}
+function isUnparenthesizedArrowParam(fn, param, sourceCode) {
+  if (fn.type !== AST_NODE_TYPES.ArrowFunctionExpression) {
+    return false;
+  }
+  if (fn.params.length !== 1 || fn.params[0] !== param) {
+    return false;
+  }
+  return sourceCode.getTokenBefore(param)?.value !== "(";
+}
+function* insertWrappedAnnotations(fixer, param, paramTypeText, returnTypeText) {
+  yield fixer.insertTextBefore(param, "(");
+  const paramPart = paramTypeText ? `: ${paramTypeText}` : "";
+  const returnPart = returnTypeText ? `: ${returnTypeText}` : "";
+  yield fixer.insertTextAfter(param, `${paramPart})${returnPart}`);
+}
+function extractTypedDocumentNodeArgs(typeAnnotation, sourceCode) {
+  const type = typeAnnotation?.typeAnnotation;
+  if (type?.type !== AST_NODE_TYPES.TSTypeReference) {
+    return null;
+  }
+  if (type.typeName.type !== AST_NODE_TYPES.Identifier || type.typeName.name !== "TypedDocumentNode") {
+    return null;
+  }
+  const args = type.typeArguments?.params;
+  if (!args || args.length < 2) {
+    return null;
+  }
+  return {
+    data: sourceCode.getText(args[0]),
+    variables: sourceCode.getText(args[1])
+  };
+}
+function isImportSpecifier(specifier) {
+  return specifier.type === AST_NODE_TYPES.ImportSpecifier;
+}
+const cellTypeAnnotations = createRule({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Sets the types on a Cell file's lifecycle hooks and render props to the correct @cedarjs/web Cell types"
+    },
+    messages: {
+      needsTypeAnnotation: "The `{{name}}` {{kind}} needs a type annotation of `{{typeName}}` ({{location}}).",
+      beforeQueryParamNeedsType: "`beforeQuery`'s first parameter needs a type annotation. Cedar infers the Cell's external props from it, so leaving it untyped degrades type checking at every call site of this Cell."
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const filename = basename(context.filename);
+    const filenameIndicatesCell = filename.endsWith("Cell.tsx");
+    let hasQueryOrFragment = false;
+    let hasSuccessExport = false;
+    let derivedQueryTypes = null;
+    let webTypeImport = null;
+    const importedWebTypeNames = /* @__PURE__ */ new Set();
+    const checks = [];
+    const claimedImportNames = /* @__PURE__ */ new Set();
+    function needsImportEdit(importName) {
+      if (!importName) {
+        return false;
+      }
+      if (importedWebTypeNames.has(importName)) {
+        return false;
+      }
+      if (claimedImportNames.has(importName)) {
+        return false;
+      }
+      claimedImportNames.add(importName);
+      return true;
+    }
+    function* importEdit(fixer, importName) {
+      const specifiers = webTypeImport?.specifiers.filter(isImportSpecifier) ?? [];
+      const lastSpecifier = specifiers[specifiers.length - 1];
+      if (lastSpecifier) {
+        yield fixer.insertTextAfter(lastSpecifier, `, ${importName}`);
+        return;
+      }
+      yield fixer.insertTextBeforeRange(
+        [0, 0],
+        `import type { ${importName} } from '@cedarjs/web'
+`
+      );
+    }
+    function checkBeforeQuery(fn, reportNode) {
+      const variablesType = derivedQueryTypes?.variables ?? "Record<string, unknown>";
+      if (!fn.returnType) {
+        const typeName = `CellBeforeQueryResult<${variablesType}>`;
+        const shouldImport = needsImportEdit("CellBeforeQueryResult");
+        context.report({
+          node: reportNode,
+          messageId: "needsTypeAnnotation",
+          data: {
+            name: "beforeQuery",
+            typeName,
+            kind: "function",
+            location: "return type"
+          },
+          *fix(fixer) {
+            const [firstParam2] = fn.params;
+            if (firstParam2 && isUnparenthesizedArrowParam(fn, firstParam2, sourceCode)) {
+              yield* insertWrappedAnnotations(fixer, firstParam2, null, typeName);
+            } else {
+              const closingParen = getParamsClosingParen(sourceCode, fn);
+              if (!closingParen) {
+                return;
+              }
+              yield fixer.insertTextAfter(closingParen, `: ${typeName}`);
+            }
+            if (shouldImport) {
+              yield* importEdit(fixer, "CellBeforeQueryResult");
+            }
+          }
+        });
+      }
+      const firstParam = fn.params[0];
+      if (firstParam && !paramHasTypeAnnotation(firstParam)) {
+        context.report({
+          node: reportNode,
+          messageId: "beforeQueryParamNeedsType"
+        });
+      }
+    }
+    function checkAfterQuery(fn, reportNode) {
+      const firstParam = fn.params[0];
+      const missingParam = !!firstParam && !paramHasTypeAnnotation(firstParam);
+      if (!missingParam) {
+        return;
+      }
+      const shouldImport = needsImportEdit("DataObject");
+      context.report({
+        node: reportNode,
+        messageId: "needsTypeAnnotation",
+        data: {
+          name: "afterQuery",
+          typeName: "DataObject",
+          kind: "function",
+          location: "parameter"
+        },
+        *fix(fixer) {
+          if (firstParam && isUnparenthesizedArrowParam(fn, firstParam, sourceCode)) {
+            yield* insertWrappedAnnotations(
+              fixer,
+              firstParam,
+              "DataObject",
+              null
+            );
+          } else if (firstParam) {
+            yield fixer.insertTextAfter(
+              getParamPattern(firstParam),
+              ": DataObject"
+            );
+          }
+          if (shouldImport) {
+            yield* importEdit(fixer, "DataObject");
+          }
+        }
+      });
+    }
+    function checkIsEmpty(fn, reportNode) {
+      const [responseParam, optionsParam] = fn.params;
+      const missingResponseType = !!responseParam && !paramHasTypeAnnotation(responseParam);
+      const missingOptionsType = !!optionsParam && !paramHasTypeAnnotation(optionsParam);
+      if (!missingResponseType && !missingOptionsType) {
+        return;
+      }
+      const shouldImport = needsImportEdit("DataObject");
+      context.report({
+        node: reportNode,
+        messageId: "needsTypeAnnotation",
+        data: {
+          name: "isEmpty",
+          typeName: "DataObject",
+          kind: "function",
+          location: "parameters"
+        },
+        *fix(fixer) {
+          if (responseParam && isUnparenthesizedArrowParam(fn, responseParam, sourceCode)) {
+            yield* insertWrappedAnnotations(
+              fixer,
+              responseParam,
+              missingResponseType ? "DataObject" : null,
+              null
+            );
+          } else {
+            if (missingResponseType && responseParam) {
+              yield fixer.insertTextAfter(
+                getParamPattern(responseParam),
+                ": DataObject"
+              );
+            }
+            if (missingOptionsType && optionsParam) {
+              yield fixer.insertTextAfter(
+                getParamPattern(optionsParam),
+                ": { isDataEmpty: (data: DataObject) => boolean }"
+              );
+            }
+          }
+          if (shouldImport) {
+            yield* importEdit(fixer, "DataObject");
+          }
+        }
+      });
+    }
+    function checkRenderProp(name, fn, reportNode) {
+      const [propsParam] = fn.params;
+      if (!propsParam || paramHasTypeAnnotation(propsParam)) {
+        return;
+      }
+      const variablesType = derivedQueryTypes?.variables;
+      let insertText;
+      if (name === "Success") {
+        insertText = derivedQueryTypes ? `CellSuccessProps<${derivedQueryTypes.data}, ${derivedQueryTypes.variables}>` : "CellSuccessProps";
+      } else if (name === "Failure") {
+        insertText = variablesType ? `CellFailureProps<${variablesType}>` : "CellFailureProps";
+      } else {
+        insertText = variablesType ? `CellLoadingProps<${variablesType}>` : "CellLoadingProps";
+      }
+      const importName = `Cell${name}Props`;
+      const shouldImport = needsImportEdit(importName);
+      context.report({
+        node: reportNode,
+        messageId: "needsTypeAnnotation",
+        data: {
+          name,
+          typeName: insertText,
+          kind: "component",
+          location: "parameter"
+        },
+        *fix(fixer) {
+          if (isUnparenthesizedArrowParam(fn, propsParam, sourceCode)) {
+            yield* insertWrappedAnnotations(fixer, propsParam, insertText, null);
+          } else {
+            yield fixer.insertTextAfter(
+              getParamPattern(propsParam),
+              `: ${insertText}`
+            );
+          }
+          if (shouldImport) {
+            yield* importEdit(fixer, importName);
+          }
+        }
+      });
+    }
+    function checkExport(name, fn, reportNode) {
+      if (name === "beforeQuery") {
+        checkBeforeQuery(fn, reportNode);
+      } else if (name === "afterQuery") {
+        checkAfterQuery(fn, reportNode);
+      } else if (name === "isEmpty") {
+        checkIsEmpty(fn, reportNode);
+      } else if (RENDER_PROP_EXPORTS.has(name)) {
+        checkRenderProp(name, fn, reportNode);
+      }
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== "@cedarjs/web") {
+          return;
+        }
+        if (node.importKind === "type") {
+          webTypeImport = node;
+        }
+        node.specifiers.filter(isImportSpecifier).forEach((specifier) => {
+          if (node.importKind === "type" || specifier.importKind === "type") {
+            importedWebTypeNames.add(specifier.local.name);
+          }
+        });
+      },
+      ExportNamedDeclaration(node) {
+        if (node.declaration?.type === AST_NODE_TYPES.FunctionDeclaration) {
+          const fn = node.declaration;
+          const idNode = fn.id;
+          if (!idNode) {
+            return;
+          }
+          const name = idNode.name;
+          if (name === "Success") {
+            hasSuccessExport = true;
+          }
+          if (LIFECYCLE_EXPORTS.has(name) || RENDER_PROP_EXPORTS.has(name)) {
+            checks.push(() => checkExport(name, fn, idNode));
+          }
+          return;
+        }
+        if (node.declaration?.type !== AST_NODE_TYPES.VariableDeclaration) {
+          return;
+        }
+        node.declaration.declarations.forEach((vd) => {
+          if (vd.type !== AST_NODE_TYPES.VariableDeclarator || vd.id.type !== AST_NODE_TYPES.Identifier) {
+            return;
+          }
+          const name = vd.id.name;
+          if (name === "QUERY") {
+            derivedQueryTypes ||= extractTypedDocumentNodeArgs(
+              vd.id.typeAnnotation,
+              sourceCode
+            );
+            hasQueryOrFragment = true;
+            return;
+          }
+          if (name === "FRAGMENT") {
+            hasQueryOrFragment = true;
+            return;
+          }
+          if (name === "Success") {
+            hasSuccessExport = true;
+          }
+          if ((LIFECYCLE_EXPORTS.has(name) || RENDER_PROP_EXPORTS.has(name)) && (vd.init?.type === AST_NODE_TYPES.ArrowFunctionExpression || vd.init?.type === AST_NODE_TYPES.FunctionExpression)) {
+            const fn = vd.init;
+            checks.push(() => checkExport(name, fn, vd.id));
+          }
+        });
+      },
+      "Program:exit"() {
+        const isCellFile = filenameIndicatesCell && hasQueryOrFragment && hasSuccessExport;
+        if (!isCellFile) {
+          return;
+        }
+        checks.forEach((check) => check());
+      }
+    };
+  }
+});
+export {
+  cellTypeAnnotations
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cedarjs/eslint-plugin",
-  "version": "6.0.0-rc.312",
+  "version": "6.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cedarjs/cedar.git",
@@ -27,7 +27,7 @@
     "eslint": "8.57.1"
   },
   "devDependencies": {
-    "@cedarjs/framework-tools": "6.0.0-rc.312",
+    "@cedarjs/framework-tools": "6.0.0",
     "@types/eslint": "8.56.12",
     "@types/estree": "1.0.9",
     "@typescript-eslint/parser": "8.60.1",