@qq99/eslint-plugin-solid 0.18.0-no-reactive-read-in-effect-callback.0

package/src/rules/valid-use-server.ts

@@ -0,0 +1,192 @@
+/**
+ * FIXME: remove this comments and import when below issue is fixed.
+ * This import is necessary for type generation due to a bug in the TypeScript compiler.
+ * See: https://github.com/microsoft/TypeScript/issues/42873
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { TSESLint } from "@typescript-eslint/utils";
+
+import { TSESTree as T, ESLintUtils } from "@typescript-eslint/utils";
+import {
+  findParent,
+  isFunctionNode,
+  trackImports,
+  createNameMatcher,
+  getDirectivePrologue,
+  getUseServerEligibility,
+  isInsideUseServerFunction,
+  programHasUseServerDirective,
+} from "../utils";
+
+const createRule = ESLintUtils.RuleCreator.withoutDocs;
+
+type MessageIds =
+  | "misplacedDirective"
+  | "templateDirective"
+  | "ineligiblePosition"
+  | "nonFunctionExport"
+  | "clientWrapper";
+type Options = [{ clientWrappers: string[] }];
+
+const POSITION_LABELS = {
+  objectMethod: "an object method",
+  accessor: "a getter or setter",
+  classMethod: "a class method",
+} as const;
+
+/**
+ * Declaration wrappers whose behavior lives in the client bundle. In a
+ * module-level "use server" file the client build replaces every export with
+ * a bare server reference, so these wrapper calls are compiled out of the
+ * client entirely: `GET`/`withMeta` metadata never reaches the client proxy
+ * (calls silently go over POST), `live` sources never get their live
+ * transport, and the router's `query`/`action`/`liveQuery` integration
+ * (caching, dedup, submission tracking) never happens.
+ */
+const CLIENT_WRAPPERS = ["GET", "live", "withMeta", "query", "action", "liveQuery"];
+const WRAPPER_SOURCES = /^(?:solid-js|@solidjs\/(?:web|router|start))(?:\/|$)/;
+
+const isDefinitelyNotFunction = (node: T.Node): boolean =>
+  node.type === "Literal" ||
+  node.type === "TemplateLiteral" ||
+  node.type === "ArrayExpression" ||
+  node.type === "ObjectExpression";
+
+export default createRule<Options, MessageIds>({
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        'Enforce that "use server" directives are placed where the compiler honors them, and that module-level directive files export working server functions.',
+      url: "https://github.com/solidjs-community/eslint-plugin-solid/blob/main/packages/eslint-plugin-solid/docs/valid-use-server.md",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          clientWrappers: {
+            description:
+              "Additional function names treated as client-side declaration wrappers that must not be called inside a module-level \"use server\" file. Supports exact names, '*' wildcards, and regexes given as '/pattern/' strings. GET, live, withMeta, query, action, and liveQuery are always included.",
+            type: "array",
+            items: { type: "string" },
+            default: [],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      misplacedDirective:
+        'The "use server" directive only takes effect as the first statement of a function body or module; here it is an ordinary expression statement and the code stays on the client.',
+      templateDirective:
+        'A template literal is never a directive; this code stays on the client. Use a plain string: "use server".',
+      ineligiblePosition:
+        'The "use server" directive in {{position}} is silently ignored — the function is never extracted to the server. Use a standalone function, a function-valued property, or a block-bodied arrow instead.',
+      nonFunctionExport:
+        "Every export of a module-level \"use server\" file is registered as a server function; '{{name}}' is not a function and will fail the server at boot. Move non-function exports to another module.",
+      clientWrapper:
+        "In a module-level \"use server\" file the client receives bare server references, so '{{name}}' never runs on the client and its behavior is silently lost. Wrap the imported server function in a shared module instead, or move the directive inside the wrapped function.",
+    },
+  },
+  defaultOptions: [{ clientWrappers: [] }],
+  create(context, [options]) {
+    const { matchImport, handleImportDeclaration } = trackImports(WRAPPER_SOURCES);
+    const matchesCustomWrapper = createNameMatcher(options.clientWrappers);
+    let moduleLevel = false;
+
+    const checkExportedValue = (node: T.Node, name: string) => {
+      if (isDefinitelyNotFunction(node)) {
+        context.report({ node, messageId: "nonFunctionExport", data: { name } });
+      }
+    };
+
+    return {
+      Program(node) {
+        moduleLevel = programHasUseServerDirective(node);
+      },
+      ImportDeclaration: handleImportDeclaration,
+      ExpressionStatement(node) {
+        const { expression } = node;
+        const isTemplate =
+          expression.type === "TemplateLiteral" &&
+          expression.expressions.length === 0 &&
+          expression.quasis.length === 1 &&
+          expression.quasis[0].value.cooked === "use server";
+        const isString = expression.type === "Literal" && expression.value === "use server";
+        if (!isTemplate && !isString) return;
+
+        if (isTemplate) {
+          context.report({ node, messageId: "templateDirective" });
+          return;
+        }
+
+        // In a module-level directive file, or nested inside an extracted
+        // server function, the whole scope already runs on the server —
+        // stray inner directives are ignored by the transform and harmless.
+        if (moduleLevel) return;
+        const nearestFunction = findParent(node, isFunctionNode);
+        if (
+          nearestFunction &&
+          isFunctionNode(nearestFunction) &&
+          isInsideUseServerFunction(nearestFunction)
+        ) {
+          return;
+        }
+
+        const parent = node.parent;
+        const enclosingFunction =
+          parent?.type === "BlockStatement" && isFunctionNode(parent.parent) ? parent.parent : null;
+        if (
+          parent?.type !== "Program" &&
+          (parent?.type !== "BlockStatement" || !enclosingFunction)
+        ) {
+          // A string statement in a plain block (if/for body, bare block):
+          // blocks have no directive prologue.
+          context.report({ node, messageId: "misplacedDirective" });
+          return;
+        }
+
+        const body = parent.body;
+        if (!getDirectivePrologue(body).includes(node)) {
+          context.report({ node, messageId: "misplacedDirective" });
+          return;
+        }
+
+        if (enclosingFunction && !isInsideUseServerFunction(enclosingFunction)) {
+          const eligibility = getUseServerEligibility(enclosingFunction);
+          if (eligibility !== "eligible") {
+            context.report({
+              node,
+              messageId: "ineligiblePosition",
+              data: { position: POSITION_LABELS[eligibility] },
+            });
+          }
+        }
+      },
+      ExportNamedDeclaration(node) {
+        if (!moduleLevel || !node.declaration) return;
+        if (node.declaration.type === "VariableDeclaration") {
+          for (const declarator of node.declaration.declarations) {
+            if (declarator.init && declarator.id.type === "Identifier") {
+              checkExportedValue(declarator.init, declarator.id.name);
+            }
+          }
+        }
+      },
+      ExportDefaultDeclaration(node) {
+        if (!moduleLevel) return;
+        checkExportedValue(node.declaration, "default");
+      },
+      CallExpression(node) {
+        if (!moduleLevel || node.callee.type !== "Identifier") return;
+        // Only module-scope calls: wrapper calls inside functions are just
+        // server-side code, which is the caller's business.
+        if (findParent(node, isFunctionNode) != null) return;
+        const name = node.callee.name;
+        if (matchImport(CLIENT_WRAPPERS, name) || matchesCustomWrapper(name)) {
+          context.report({ node, messageId: "clientWrapper", data: { name } });
+        }
+      },
+    };
+  },
+});

package/src/rules/validate-jsx-nesting.ts

@@ -0,0 +1 @@
+export {};

package/src/utils/reactive-imports.ts

@@ -0,0 +1,382 @@
+import ts from "typescript";
+import { createReactiveTypeResolver } from "./reactive-types";
+import {
+  Value,
+  object,
+  scalar,
+  setter,
+  container,
+  asStore,
+  propertyValue,
+  mergeValues,
+  awaitedValue,
+  promiseValue,
+  callResult,
+  propertiesOf,
+  iteratorValue,
+  iterationValue,
+  iterationReturn,
+} from "./reactive-values";
+
+interface Module {
+  source: ts.SourceFile;
+  checker: ts.TypeChecker;
+}
+
+/**
+ * Follow return values in local source modules. Each module is bound on its
+ * own, without libraries or dependencies, solely to resolve lexical bindings.
+ * This does not type-check a project or execute the imported code, and works
+ * in Oxlint without typescript-eslint's parser services.
+ *
+ * Caches live for one linted file so editor runs cannot retain stale sources.
+ * File/step limits bound work on cyclic or unusually large module graphs.
+ */
+export function createReactiveImportResolver(filename: string, solidSource: RegExp, text: string) {
+  const modules = new Map<string, Module | null>();
+  let resolutionOptions: ts.CompilerOptions | undefined;
+  let steps = 0;
+
+  const load = (file: string): Module | null => {
+    if (modules.has(file)) return modules.get(file)!;
+    if (modules.size >= 32) return null;
+    modules.set(file, null);
+    const options: ts.CompilerOptions = {
+      allowJs: true,
+      noLib: true,
+      noResolve: true,
+      types: [],
+      target: ts.ScriptTarget.Latest,
+      module: ts.ModuleKind.ESNext,
+    };
+    const host = ts.createCompilerHost(options);
+    // No full program graph: the checker is only used for this file's symbols.
+    const getSourceFile = host.getSourceFile.bind(host);
+    host.getSourceFile = (name, languageVersion) =>
+      name === file ? getSourceFile(name, languageVersion) : undefined;
+    const program = ts.createProgram([file], options, host);
+    const source = program.getSourceFile(file);
+    if (!source || program.getSyntacticDiagnostics(source).length) return null;
+    const module = { source, checker: program.getTypeChecker() };
+    modules.set(file, module);
+    return module;
+  };
+
+  const resolveFile = (specifier: string, from: string): string | undefined => {
+    // The browser standalone build and virtual lint inputs have no file graph.
+    if (!ts.sys?.fileExists || !filename || !ts.sys.fileExists(filename)) return undefined;
+    if (!resolutionOptions) {
+      const config = ts.findConfigFile(filename, ts.sys.fileExists);
+      resolutionOptions = config
+        ? ts.getParsedCommandLineOfConfigFile(
+            config,
+            {},
+            {
+              ...ts.sys,
+              onUnRecoverableConfigFileDiagnostic() {},
+            }
+          )?.options
+        : undefined;
+      resolutionOptions ??= { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true };
+    }
+    const resolved = ts.resolveModuleName(
+      specifier,
+      from,
+      resolutionOptions,
+      ts.sys
+    ).resolvedModule;
+    // Library implementations are an explicit knowledge boundary. Do not crawl
+    // node_modules or mistake declarations for an implementation.
+    if (
+      !resolved ||
+      resolved.isExternalLibraryImport ||
+      /(?:^|[/\\])node_modules[/\\]|\.d\.[cm]?ts$/.test(resolved.resolvedFileName)
+    ) {
+      return undefined;
+    }
+    return resolved.resolvedFileName;
+  };
+
+  const importSource = (node: ts.Node): string | null => {
+    for (let parent: ts.Node | undefined = node; parent; parent = parent.parent) {
+      if (ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent)) {
+        return parent.moduleSpecifier && ts.isStringLiteral(parent.moduleSpecifier)
+          ? parent.moduleSpecifier.text
+          : null;
+      }
+    }
+    return null;
+  };
+
+  const imported = (
+    source: string,
+    name: string,
+    from: string,
+    args: Value[] | undefined,
+    seen: Set<ts.Node>
+  ): Value => {
+    if (++steps > 1000) return null;
+    if (
+      args &&
+      source === "@tanstack/solid-query" &&
+      (name === "useQuery" || name === "useInfiniteQuery")
+    )
+      return object;
+    if (args && solidSource.test(source)) {
+      if (name === "createSignal" || name === "createOptimistic") {
+        return container([
+          ["0", { kind: "accessor", result: args[0] ?? null }],
+          ["1", setter],
+        ]);
+      }
+      if (name === "createMemo") return { kind: "accessor", result: null };
+      if (name === "createStore" || name === "createOptimisticStore") {
+        return container([
+          ["0", asStore(args[0] ?? args[1] ?? null)],
+          ["1", setter],
+        ]);
+      }
+      if (name === "createProjection") return asStore(args[1] ?? null);
+      if (name === "omit") return args[0] ?? null;
+      if (name === "merge") return args.reduce(mergeValues, null);
+    }
+    const file = resolveFile(source, from);
+    const module = file ? load(file) : null;
+    if (!module) return null;
+    const symbol = module.checker.getSymbolAtLocation(module.source);
+    const exported =
+      symbol && module.checker.getExportsOfModule(symbol).find((s) => s.name === name);
+    if (exported) return evaluateSymbol(module, exported, args, new Map(), seen);
+    // The single-file binder cannot expand export-star declarations itself.
+    if (name !== "default") {
+      for (const statement of module.source.statements) {
+        if (ts.isExportDeclaration(statement) && !statement.exportClause && !statement.isTypeOnly) {
+          const source = importSource(statement);
+          if (!source || seen.has(statement)) continue;
+          const value = imported(
+            source,
+            name,
+            module.source.fileName,
+            args,
+            new Set(seen).add(statement)
+          );
+          if (value) return value;
+        }
+      }
+    }
+    return null;
+  };
+
+  const evaluateSymbol = (
+    module: Module,
+    symbol: ts.Symbol | undefined,
+    args: Value[] | undefined,
+    env: Map<ts.Symbol, Value>,
+    seen: Set<ts.Node>
+  ): Value => {
+    if (!symbol) return null;
+    if (env.has(symbol)) {
+      const value = env.get(symbol)!;
+      return args ? callResult(value) : value;
+    }
+    const declarations = symbol.declarations ?? [];
+    const declaration =
+      declarations.find((d) => ts.isFunctionDeclaration(d) && d.body) ?? declarations[0];
+    return declaration ? evaluate(module, declaration, args, env, seen) : null;
+  };
+
+  const evaluate = (
+    module: Module,
+    node: ts.Node,
+    args: Value[] | undefined,
+    env: Map<ts.Symbol, Value>,
+    seen: Set<ts.Node>
+  ): Value => {
+    if (++steps > 1000 || seen.has(node)) return null;
+    const next = new Set(seen).add(node);
+    const valueOf = (node: ts.Node): Value => evaluate(module, node, undefined, env, next);
+    if (ts.isAwaitExpression(node)) {
+      const value = awaitedValue(valueOf(node.expression));
+      return args ? callResult(value) : value;
+    }
+    if (ts.isYieldExpression(node)) {
+      let value =
+        node.asteriskToken && node.expression ? iterationReturn(valueOf(node.expression)) : null;
+      let parent: ts.Node | undefined = node.parent;
+      while (parent && !ts.isFunctionLike(parent)) parent = parent.parent;
+      if (parent && ts.getCombinedModifierFlags(parent as ts.Declaration) & ts.ModifierFlags.Async)
+        value = awaitedValue(value);
+      return args ? callResult(value) : value;
+    }
+    if (
+      ts.isParenthesizedExpression(node) ||
+      ts.isAsExpression(node) ||
+      ts.isTypeAssertionExpression(node) ||
+      ts.isNonNullExpression(node) ||
+      ts.isSatisfiesExpression?.(node)
+    ) {
+      return evaluate(module, node.expression, args, env, next);
+    }
+    if (ts.isIdentifier(node))
+      return evaluateSymbol(module, module.checker.getSymbolAtLocation(node), args, env, next);
+    if (ts.isImportSpecifier(node) || ts.isImportClause(node) || ts.isExportSpecifier(node)) {
+      if (node.isTypeOnly) return null;
+      const source = importSource(node);
+      if (source) {
+        const name = ts.isImportClause(node) ? "default" : (node.propertyName ?? node.name).text;
+        return imported(source, name, module.source.fileName, args, next);
+      }
+      if (ts.isExportSpecifier(node)) {
+        return evaluateSymbol(
+          module,
+          module.checker.getExportSpecifierLocalTargetSymbol(node),
+          args,
+          env,
+          next
+        );
+      }
+    }
+    if (ts.isExportAssignment(node)) return evaluate(module, node.expression, args, env, next);
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      if (!(node.parent.flags & ts.NodeFlags.Const)) return null;
+      return evaluate(module, node.initializer, args, env, next);
+    }
+    if (
+      ts.isBindingElement(node) &&
+      ts.isArrayBindingPattern(node.parent) &&
+      ts.isVariableDeclaration(node.parent.parent)
+    ) {
+      const tuple = valueOf(node.parent.parent);
+      const value = propertyValue(tuple, String(node.parent.elements.indexOf(node)));
+      return args ? callResult(value) : value;
+    }
+    if (
+      ts.isArrowFunction(node) ||
+      ts.isFunctionExpression(node) ||
+      ts.isFunctionDeclaration(node)
+    ) {
+      if (!args || !node.body) return null;
+      const async = Boolean(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Async);
+      const wrap = (value: Value): Value => (async ? promiseValue(value) : value);
+      const local = new Map(env);
+      node.parameters.forEach((param, index) => {
+        if (ts.isIdentifier(param.name)) {
+          const symbol = module.checker.getSymbolAtLocation(param.name);
+          if (symbol)
+            local.set(
+              symbol,
+              args[index] ?? (param.initializer ? valueOf(param.initializer) : null)
+            );
+        }
+      });
+      if (!ts.isBlock(node.body)) return wrap(evaluate(module, node.body, undefined, local, next));
+      let result: Value = null;
+      let yielded: Value = null;
+      const visit = (child: ts.Node): void => {
+        if (ts.isFunctionLike(child) || ts.isClassLike(child)) return;
+        if (ts.isReturnStatement(child) && child.expression) {
+          result = mergeValues(result, evaluate(module, child.expression, undefined, local, next));
+        } else if (node.asteriskToken && ts.isYieldExpression(child) && child.expression) {
+          const value = evaluate(module, child.expression, undefined, local, next);
+          yielded = mergeValues(yielded, child.asteriskToken ? iterationValue(value) : value);
+        }
+        // A return expression may itself contain yield or yield*.
+        ts.forEachChild(child, visit);
+      };
+      visit(node.body);
+      return node.asteriskToken ? iteratorValue(async, yielded, result) : wrap(result);
+    }
+    if (ts.isCallExpression(node)) {
+      if (
+        ts.isPropertyAccessExpression(node.expression) &&
+        ts.isIdentifier(node.expression.expression) &&
+        node.expression.expression.text === "Promise" &&
+        node.expression.name.text === "resolve" &&
+        !module.checker.getSymbolAtLocation(node.expression.expression)?.declarations?.length
+      ) {
+        return args ? null : promiseValue(node.arguments[0] ? valueOf(node.arguments[0]) : null);
+      }
+      const value = evaluate(module, node.expression, node.arguments.map(valueOf), env, next);
+      return args ? callResult(value) : value;
+    }
+    if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+      const key = ts.isPropertyAccessExpression(node)
+        ? node.name.text
+        : ts.isStringLiteralLike(node.argumentExpression) ||
+          ts.isNumericLiteral(node.argumentExpression)
+        ? node.argumentExpression.text
+        : null;
+      if (key !== null && ts.isIdentifier(node.expression)) {
+        const declaration = module.checker.getSymbolAtLocation(node.expression)?.declarations?.[0];
+        if (declaration && ts.isNamespaceImport(declaration)) {
+          const source = importSource(declaration);
+          if (source) return imported(source, key, module.source.fileName, args, next);
+        }
+      }
+      const value = propertyValue(valueOf(node.expression), key);
+      return args ? callResult(value) : value;
+    }
+    if (args) return null;
+    if (ts.isObjectLiteralExpression(node)) {
+      const properties = new Map<string, Value>();
+      for (const property of node.properties) {
+        if (ts.isSpreadAssignment(property)) {
+          const value = valueOf(property.expression);
+          for (const [key, entry] of propertiesOf(value)) properties.set(key, entry);
+        } else if (ts.isPropertyAssignment(property) && !ts.isComputedPropertyName(property.name)) {
+          properties.set(property.name.text, valueOf(property.initializer));
+        } else if (ts.isShorthandPropertyAssignment(property)) {
+          properties.set(
+            property.name.text,
+            evaluateSymbol(
+              module,
+              module.checker.getShorthandAssignmentValueSymbol(property),
+              undefined,
+              env,
+              next
+            )
+          );
+        }
+      }
+      return { kind: "plain", properties };
+    }
+    if (ts.isArrayLiteralExpression(node))
+      return container(node.elements.map((element, i) => [String(i), valueOf(element)]));
+    if (ts.isConditionalExpression(node))
+      return mergeValues(valueOf(node.whenTrue), valueOf(node.whenFalse));
+    if (ts.isBinaryExpression(node)) {
+      return [
+        ts.SyntaxKind.AmpersandAmpersandToken,
+        ts.SyntaxKind.BarBarToken,
+        ts.SyntaxKind.QuestionQuestionToken,
+      ].includes(node.operatorToken.kind)
+        ? mergeValues(valueOf(node.left), valueOf(node.right))
+        : scalar;
+    }
+    if (
+      ts.isLiteralExpression(node) ||
+      ts.isTemplateExpression(node) ||
+      ts.isPrefixUnaryExpression(node) ||
+      node.kind === ts.SyntaxKind.TrueKeyword ||
+      node.kind === ts.SyntaxKind.FalseKeyword
+    )
+      return scalar;
+    return null;
+  };
+
+  return {
+    value(source: string, name: string, args?: Value[]): Value {
+      steps = 0;
+      return imported(source, name, filename, args, new Set());
+    },
+    type: createReactiveTypeResolver(
+      filename,
+      text,
+      (source, from) => {
+        const file = resolveFile(source, from);
+        return file ? load(file) : null;
+      },
+      solidSource
+    ),
+  };
+}