@jameswyse/oxc-config 0.1.0

package/dist/rules/no-generic-file-suffix.js

@@ -0,0 +1,74 @@
+import { basename } from "node:path";
+import { defineRule } from "@oxlint/plugins";
+const companionSegments = new Set(["test", "spec", "stories", "story", "bench", "e2e"]);
+const genericSegment = /(?:^|[-_])(?:policy|contract)$/i;
+const genericSuffix = /[a-z0-9](?:Policy|Contract)$/;
+const standardTerms = [
+    "contentsecuritypolicy",
+    "permissionspolicy",
+    "featurepolicy",
+    "referrerpolicy",
+    "privacypolicy",
+    "crossoriginopenerpolicy",
+    "crossoriginembedderpolicy",
+    "crossoriginresourcepolicy",
+];
+function fileName(filename) {
+    const segments = basename(filename).split(".").slice(0, -1);
+    if (segments.at(-1) === "d") {
+        segments.pop();
+    }
+    const name = segments.at(-1);
+    if (name === undefined) {
+        return null;
+    }
+    return segments.length > 1 && companionSegments.has(name.toLowerCase()) ? null : name;
+}
+function isGeneric(name) {
+    const normalised = name.replaceAll(/[-_]/g, "").toLowerCase();
+    return ((genericSegment.test(name) || genericSuffix.test(name)) &&
+        !standardTerms.some((term) => normalised.endsWith(term)));
+}
+function declaredNames(declaration) {
+    if (declaration.type === "VariableDeclaration") {
+        return declaration.declarations.flatMap((declarator) => declarator.id.type === "Identifier" ? [declarator.id.name] : []);
+    }
+    return declaration.id?.type === "Identifier" ? [declaration.id.name] : [];
+}
+function exportedNames(program) {
+    return program.body.flatMap((statement) => {
+        if (statement.type !== "ExportNamedDeclaration") {
+            return [];
+        }
+        if (statement.declaration) {
+            return declaredNames(statement.declaration);
+        }
+        return statement.specifiers.map(({ exported }) => exported.type === "Identifier" ? exported.name : exported.value);
+    });
+}
+export const noGenericFileSuffix = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Name files after what they contain instead of `Contract` or `Policy`. Companions follow their owner's name.",
+        },
+        schema: [],
+        messages: {
+            suffix: "Rename '{{name}}' after what it contains. `Contract` and `Policy` hide whether the file holds types, constants, validation, or configuration; prefer a name such as `quoteEligibility`.",
+        },
+    },
+    create(context) {
+        const name = fileName(context.filename);
+        if (!name || !isGeneric(name)) {
+            return {};
+        }
+        return {
+            Program(node) {
+                const owned = name.toLowerCase();
+                if (!exportedNames(node).some((exported) => exported.toLowerCase() === owned)) {
+                    context.report({ node, messageId: "suffix", data: { name: basename(context.filename) } });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-pass-through-function.d.ts

@@ -0,0 +1 @@
+export declare const noPassThroughFunction: import("@oxlint/plugins").Rule;

package/dist/rules/no-pass-through-function.js

@@ -0,0 +1,106 @@
+import { defineRule } from "@oxlint/plugins";
+import { propertyName, variableFor } from "../shared/index.js";
+function delegatedCall(fn) {
+    let expression = fn.body;
+    if (expression?.type === "BlockStatement") {
+        const [statement, ...otherStatements] = expression.body;
+        if (statement === undefined || otherStatements.length > 0) {
+            return null;
+        }
+        if (statement.type === "ReturnStatement") {
+            expression = statement.argument;
+        }
+        else if (statement.type === "ExpressionStatement" && !statement.directive) {
+            expression = statement.expression;
+        }
+        else {
+            return null;
+        }
+    }
+    if (expression?.type === "AwaitExpression") {
+        expression = expression.argument;
+    }
+    return expression?.type === "CallExpression" && !expression.optional ? expression : null;
+}
+function passesParameters(fn, call) {
+    if (fn.params.length !== call.arguments.length) {
+        return false;
+    }
+    return fn.params.every((parameter, index) => {
+        const argument = call.arguments[index];
+        if (parameter.type === "Identifier") {
+            return argument?.type === "Identifier" && argument.name === parameter.name;
+        }
+        return (parameter.type === "RestElement" &&
+            parameter.argument.type === "Identifier" &&
+            argument?.type === "SpreadElement" &&
+            argument.argument.type === "Identifier" &&
+            argument.argument.name === parameter.argument.name);
+    });
+}
+function isEffectEvent(sourceCode, callee) {
+    const definition = variableFor(sourceCode, callee)?.defs[0]?.node;
+    const init = definition?.type === "VariableDeclarator" ? definition.init : null;
+    const hook = init?.type === "CallExpression" ? init.callee : null;
+    if (hook?.type === "MemberExpression") {
+        return propertyName(hook) === "useEffectEvent";
+    }
+    return hook?.type === "Identifier" && hook.name === "useEffectEvent";
+}
+function namedFunction(fn) {
+    const parent = fn.parent;
+    if (fn.type === "FunctionDeclaration") {
+        return fn.id ? { node: fn.id, name: fn.id.name } : null;
+    }
+    if (parent.type === "VariableDeclarator" &&
+        parent.init === fn &&
+        parent.id.type === "Identifier") {
+        return { node: parent.id, name: parent.id.name };
+    }
+    if ((parent.type === "MethodDefinition" && parent.kind === "method") ||
+        (parent.type === "PropertyDefinition" && parent.value === fn)) {
+        const name = propertyName(parent);
+        return name ? { node: parent.key, name } : null;
+    }
+    return null;
+}
+export const noPassThroughFunction = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Report named functions that only forward their parameters to another function.",
+        },
+        schema: [],
+        messages: {
+            passThrough: "`{{name}}` only forwards its parameters to `{{callee}}`. Call `{{callee}}` directly, or give this function work that justifies it.",
+        },
+    },
+    create(context) {
+        function check(fn) {
+            if (fn.generator ||
+                fn.params.length === 0 ||
+                fn.returnType?.typeAnnotation.type === "TSTypePredicate") {
+                return;
+            }
+            const named = namedFunction(fn);
+            if (named === null) {
+                return;
+            }
+            const call = delegatedCall(fn);
+            if (call?.callee.type === "Identifier" &&
+                passesParameters(fn, call) &&
+                !isEffectEvent(context.sourceCode, call.callee)) {
+                context.report({
+                    node: named.node,
+                    messageId: "passThrough",
+                    data: { name: named.name, callee: call.callee.name },
+                });
+            }
+        }
+        return {
+            FunctionDeclaration: check,
+            FunctionExpression: check,
+            ArrowFunctionExpression: check,
+        };
+    },
+});

package/dist/rules/no-swallowed-errors.d.ts

@@ -0,0 +1 @@
+export declare const noSwallowedErrors: import("@oxlint/plugins").Rule;

package/dist/rules/no-swallowed-errors.js

@@ -0,0 +1,168 @@
+import { defineRule } from "@oxlint/plugins";
+import { childNodes, isGlobal, propertyName, variableFor } from "../shared/index.js";
+const nestedScopes = new Set([
+    "ArrowFunctionExpression",
+    "FunctionExpression",
+    "FunctionDeclaration",
+    "ClassBody",
+]);
+const parserFunctions = ["decodeURIComponent", "decodeURI", "atob", "BigInt", "structuredClone"];
+const parserConstructors = ["URL", "RegExp"];
+const fileSystemModules = new Set(["node:fs", "fs", "node:fs/promises", "fs/promises"]);
+function unwrap(node) {
+    if (node?.type === "TSAsExpression" ||
+        node?.type === "TSSatisfiesExpression" ||
+        node?.type === "TSNonNullExpression") {
+        return unwrap(node.expression);
+    }
+    return node;
+}
+function isFallback(sourceCode, node) {
+    const value = unwrap(node);
+    if (value === null) {
+        return true;
+    }
+    if (value.type === "Literal") {
+        return (!("regex" in value) && !("bigint" in value) && [null, false, "", 0].includes(value.value));
+    }
+    if (value.type === "Identifier") {
+        return isGlobal(sourceCode, value, "undefined");
+    }
+    if (value.type === "UnaryExpression") {
+        return value.operator === "void" && value.argument.type === "Literal";
+    }
+    if (value.type === "ArrayExpression") {
+        return value.elements.length === 0;
+    }
+    if (value.type === "ObjectExpression") {
+        return value.properties.length === 0;
+    }
+    return (value.type === "TemplateLiteral" &&
+        value.expressions.length === 0 &&
+        value.quasis[0]?.value.cooked === "");
+}
+function returnsFallback(sourceCode, statements) {
+    const [statement] = statements;
+    return (statements.length === 1 &&
+        statement?.type === "ReturnStatement" &&
+        isFallback(sourceCode, statement.argument));
+}
+function descendants(sourceCode, root) {
+    const found = [];
+    const pending = [root];
+    for (let node = pending.pop(); node !== undefined; node = pending.pop()) {
+        found.push(node);
+        if (node === root || !nestedScopes.has(node.type)) {
+            pending.push(...childNodes(node, sourceCode.visitorKeys));
+        }
+    }
+    return found;
+}
+function isFileSystemModule(sourceCode, identifier) {
+    if (identifier.type !== "Identifier") {
+        return false;
+    }
+    const definition = variableFor(sourceCode, identifier)?.defs[0];
+    return (definition?.type === "ImportBinding" &&
+        definition.parent?.type === "ImportDeclaration" &&
+        fileSystemModules.has(definition.parent.source.value));
+}
+function isFileSystemCall(sourceCode, callee) {
+    if (callee.type === "Identifier") {
+        return isFileSystemModule(sourceCode, callee);
+    }
+    if (callee.type !== "MemberExpression") {
+        return false;
+    }
+    const object = callee.object;
+    return (isFileSystemModule(sourceCode, object) ||
+        (object.type === "MemberExpression" &&
+            propertyName(object) === "promises" &&
+            isFileSystemModule(sourceCode, object.object)));
+}
+function isParser(sourceCode, node) {
+    const callee = node.callee;
+    if (node.type === "NewExpression") {
+        return (parserConstructors.some((name) => isGlobal(sourceCode, callee, name)) ||
+            (callee.type === "MemberExpression" && isGlobal(sourceCode, callee.object, "Intl")));
+    }
+    if (parserFunctions.some((name) => isGlobal(sourceCode, callee, name))) {
+        return true;
+    }
+    if (callee.type !== "MemberExpression") {
+        return false;
+    }
+    const name = propertyName(callee);
+    return ((name === "parse" && isGlobal(sourceCode, callee.object, "JSON")) ||
+        (name === "json" && node.arguments.length === 0));
+}
+function isProbe(sourceCode, node) {
+    return ((node.type === "CallExpression" || node.type === "NewExpression") &&
+        (isParser(sourceCode, node) || isFileSystemCall(sourceCode, node.callee)));
+}
+function containsProbe(sourceCode, node) {
+    return descendants(sourceCode, node).some((descendant) => isProbe(sourceCode, descendant));
+}
+function onlyProbes(sourceCode, block) {
+    const nodes = descendants(sourceCode, block);
+    return (nodes.some((node) => isProbe(sourceCode, node)) &&
+        nodes.every((node) => (node.type !== "AwaitExpression" && node.type !== "YieldExpression") ||
+            (node.argument !== null && containsProbe(sourceCode, node.argument))));
+}
+function isExistingPromise(node) {
+    const value = node.type === "ChainExpression" ? node.expression : node;
+    if (value.type === "CallExpression" &&
+        value.callee.type === "MemberExpression" &&
+        propertyName(value.callee) === "finally") {
+        return isExistingPromise(value.callee.object);
+    }
+    return value.type === "Identifier" || value.type === "MemberExpression";
+}
+function swallowingCallback(sourceCode, callback) {
+    if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") {
+        return false;
+    }
+    const body = callback.body;
+    if (body === null || body.type !== "BlockStatement") {
+        return isFallback(sourceCode, body);
+    }
+    return body.body.length === 0 || returnsFallback(sourceCode, body.body);
+}
+export const noSwallowedErrors = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Disallow catch handlers that discard the error and return a fallback." },
+        schema: [],
+        messages: {
+            swallowed: "This handler discards the error and returns a fallback, so callers cannot tell failure from an empty result. Prevent the failure, let it propagate, or return a failure the caller must handle.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            TryStatement(node) {
+                const handler = node.handler;
+                if (handler !== null &&
+                    returnsFallback(sourceCode, handler.body.body) &&
+                    !onlyProbes(sourceCode, node.block)) {
+                    context.report({ node: handler, messageId: "swallowed" });
+                }
+            },
+            CallExpression(node) {
+                const [callback, ...extraArguments] = node.arguments;
+                if (node.callee.type !== "MemberExpression" ||
+                    propertyName(node.callee) !== "catch" ||
+                    callback === undefined ||
+                    extraArguments.length > 0) {
+                    return;
+                }
+                const promise = node.callee.object;
+                if (!isExistingPromise(promise) &&
+                    !isProbe(sourceCode, promise) &&
+                    swallowingCallback(sourceCode, callback)) {
+                    context.report({ node: callback, messageId: "swallowed" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-test-timeout-overrides.d.ts

@@ -0,0 +1 @@
+export declare const noTestTimeoutOverrides: import("@oxlint/plugins").Rule;

package/dist/rules/no-test-timeout-overrides.js

@@ -0,0 +1,105 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobal, propertyName, apiReference, testModules } from "../shared/index.js";
+const optionKeys = new Set(["timeout", "retry", "retries"]);
+const configKeys = new Set(["testTimeout", "hookTimeout", "retry"]);
+const hooks = new Set(["beforeEach", "afterEach", "beforeAll", "afterAll"]);
+const functionTypes = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+function testApi(sourceCode, callee) {
+    const api = apiReference(sourceCode, callee);
+    if (api && (testModules.has(api.module) || api.module === "global")) {
+        return api.name;
+    }
+    if (isGlobal(sourceCode, callee, "describe")) {
+        return "describe";
+    }
+    const base = callee.type === "MemberExpression" ? callee.object : null;
+    if (base &&
+        propertyName(callee) === "describe" &&
+        apiReference(sourceCode, base)?.name === "test") {
+        return "describe";
+    }
+    return null;
+}
+function hasOverrideKey(node, keys) {
+    return (node?.type === "ObjectExpression" &&
+        node.properties.some((property) => {
+            const name = property.type === "Property" ? propertyName(property) : null;
+            return name !== null && keys.has(name);
+        }));
+}
+function timeoutArgument(node) {
+    return (node !== undefined &&
+        node.type !== "ObjectExpression" &&
+        node.type !== "SpreadElement" &&
+        !functionTypes.has(node.type));
+}
+function registrationOverride(sourceCode, node) {
+    const name = testApi(sourceCode, node.callee);
+    if (!name) {
+        return false;
+    }
+    if (hooks.has(name)) {
+        return timeoutArgument(node.arguments[1]) || hasOverrideKey(node.arguments[1], optionKeys);
+    }
+    if (!["test", "it", "describe"].includes(name)) {
+        return false;
+    }
+    return (node.arguments.some((argument) => hasOverrideKey(argument, optionKeys)) ||
+        timeoutArgument(node.arguments[2]));
+}
+function runnerObject(sourceCode, node, name, modules) {
+    if (isGlobal(sourceCode, node, name)) {
+        return true;
+    }
+    const api = apiReference(sourceCode, node);
+    return api?.name === name && modules.includes(api.module);
+}
+function importedTest(sourceCode, node) {
+    const api = apiReference(sourceCode, node);
+    return api?.name === "test" && api.module !== "global";
+}
+function runnerOverride(sourceCode, node) {
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression") {
+        return false;
+    }
+    const method = propertyName(callee);
+    if (method === "setConfig") {
+        return (runnerObject(sourceCode, callee.object, "vi", ["vitest", "@effect/vitest"]) &&
+            hasOverrideKey(node.arguments[0], configKeys));
+    }
+    if (method === "setTimeout") {
+        return (runnerObject(sourceCode, callee.object, "jest", ["@jest/globals"]) ||
+            importedTest(sourceCode, callee.object));
+    }
+    if (method === "slow") {
+        return importedTest(sourceCode, callee.object);
+    }
+    return (method === "configure" &&
+        callee.object.type === "MemberExpression" &&
+        propertyName(callee.object) === "describe" &&
+        importedTest(sourceCode, callee.object.object) &&
+        hasOverrideKey(node.arguments[0], optionKeys));
+}
+export const noTestTimeoutOverrides = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Make slow or flaky tests faster and deterministic instead of raising their timeout or retries.",
+        },
+        schema: [],
+        messages: {
+            override: "This test raises its timeout or retries to tolerate slow or flaky work. Make the test faster or deterministic instead.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                if (registrationOverride(sourceCode, node) || runnerOverride(sourceCode, node)) {
+                    context.report({ node, messageId: "override" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-vacuous-test-assertions.d.ts

@@ -0,0 +1 @@
+export declare const noVacuousTestAssertions: import("@oxlint/plugins").Rule;

package/dist/rules/no-vacuous-test-assertions.js

@@ -0,0 +1,71 @@
+import { defineRule } from "@oxlint/plugins";
+import { variableFor, propertyName, apiReference } from "../shared/index.js";
+const equalityMatchers = new Set(["toBe", "toEqual", "toStrictEqual"]);
+function isSingleArgumentList(values) {
+    return values.length === 1;
+}
+function primitiveLiteral(node) {
+    if (node.type === "Literal") {
+        return (!("regex" in node) &&
+            (node.value === null || ["string", "number", "boolean", "bigint"].includes(typeof node.value)));
+    }
+    return (node.type === "UnaryExpression" &&
+        ["+", "-"].includes(node.operator) &&
+        node.argument.type === "Literal" &&
+        ["number", "bigint"].includes(typeof node.argument.value));
+}
+export const noVacuousTestAssertions = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Assert runtime behaviour instead of literals or a value compared with itself.",
+        },
+        schema: [],
+        messages: {
+            vacuous: "This assertion compares fixed values or a value with itself. Assert an independently expected runtime result.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            CallExpression(node) {
+                if (node.callee.type !== "MemberExpression" || !isSingleArgumentList(node.arguments)) {
+                    return;
+                }
+                const matcher = propertyName(node.callee);
+                if (matcher === null || !equalityMatchers.has(matcher)) {
+                    return;
+                }
+                let actualCall = node.callee.object;
+                if (actualCall.type === "MemberExpression" && propertyName(actualCall) === "not") {
+                    actualCall = actualCall.object;
+                }
+                if (actualCall.type !== "CallExpression" || !isSingleArgumentList(actualCall.arguments)) {
+                    return;
+                }
+                const api = apiReference(sourceCode, actualCall.callee);
+                if (api?.name !== "expect" ||
+                    ![
+                        "vitest",
+                        "@effect/vitest",
+                        "@jest/globals",
+                        "@playwright/test",
+                        "playwright/test",
+                        "global",
+                    ].includes(api.module)) {
+                    return;
+                }
+                const actual = actualCall.arguments[0];
+                const expected = node.arguments[0];
+                const literals = primitiveLiteral(actual) && primitiveLiteral(expected);
+                const sameBinding = actual.type === "Identifier" &&
+                    expected.type === "Identifier" &&
+                    actual.name === expected.name &&
+                    variableFor(sourceCode, actual) === variableFor(sourceCode, expected);
+                if (literals || sameBinding) {
+                    context.report({ node, messageId: "vacuous" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/server-action-guard.d.ts

@@ -0,0 +1 @@
+export declare const serverActionGuard: import("@oxlint/plugins").Rule;

package/dist/rules/server-action-guard.js

@@ -0,0 +1,109 @@
+import { defineRule } from "@oxlint/plugins";
+import { optionStrings } from "../shared/rule-options.js";
+function hasDirective(statements, directive) {
+    return statements.some((statement) => statement.type === "ExpressionStatement" && statement.directive === directive);
+}
+function firstStatement(statements) {
+    return statements.find((statement) => statement.type !== "ExpressionStatement" || !statement.directive);
+}
+function awaitsGuard(expression, guards) {
+    return (expression?.type === "AwaitExpression" &&
+        expression.argument.type === "CallExpression" &&
+        expression.argument.callee.type === "Identifier" &&
+        guards.has(expression.argument.callee.name));
+}
+function startsWithGuard(action, guards) {
+    if (action.body?.type !== "BlockStatement") {
+        return false;
+    }
+    const statement = firstStatement(action.body.body);
+    if (statement?.type === "ExpressionStatement") {
+        return awaitsGuard(statement.expression, guards);
+    }
+    return (statement?.type === "VariableDeclaration" &&
+        awaitsGuard(statement.declarations[0]?.init, guards));
+}
+function functionName(node) {
+    if (node.id?.type === "Identifier") {
+        return node.id.name;
+    }
+    return node.parent.type === "VariableDeclarator" && node.parent.id.type === "Identifier"
+        ? node.parent.id.name
+        : "this action";
+}
+export const serverActionGuard = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Require every server action to start by awaiting an access guard." },
+        schema: [
+            {
+                type: "object",
+                properties: { guards: { type: "array", items: { type: "string" }, minItems: 1 } },
+                required: ["guards"],
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            missingGuard: "Server actions can be called directly. Start `{{name}}` by awaiting an access guard: {{guards}}.",
+            exportWhereDeclared: "Export each server action where it's declared, so this rule can check it starts with an access guard.",
+        },
+    },
+    create(context) {
+        const guards = new Set(optionStrings(context.options, "guards"));
+        const guardList = [...guards].join(", ");
+        let isServerModule = false;
+        function requireGuard(action) {
+            if (!startsWithGuard(action, guards)) {
+                context.report({
+                    node: action,
+                    messageId: "missingGuard",
+                    data: { name: functionName(action), guards: guardList },
+                });
+            }
+        }
+        function checkInline(node) {
+            if (!isServerModule &&
+                node.body?.type === "BlockStatement" &&
+                hasDirective(node.body.body, "use server")) {
+                requireGuard(node);
+            }
+        }
+        return {
+            Program(program) {
+                isServerModule = hasDirective(program.body, "use server");
+            },
+            ExportDefaultDeclaration(node) {
+                if (isServerModule) {
+                    context.report({ node, messageId: "exportWhereDeclared" });
+                }
+            },
+            ExportNamedDeclaration(node) {
+                if (!isServerModule || node.exportKind === "type") {
+                    return;
+                }
+                const declaration = node.declaration;
+                if (declaration === null) {
+                    context.report({ node, messageId: "exportWhereDeclared" });
+                }
+                else if (declaration.type === "FunctionDeclaration") {
+                    requireGuard(declaration);
+                }
+                else if (declaration.type === "VariableDeclaration") {
+                    for (const declarator of declaration.declarations) {
+                        const action = declarator.init;
+                        if (action?.type === "ArrowFunctionExpression" ||
+                            action?.type === "FunctionExpression") {
+                            requireGuard(action);
+                        }
+                        else {
+                            context.report({ node: declarator, messageId: "exportWhereDeclared" });
+                        }
+                    }
+                }
+            },
+            FunctionDeclaration: checkInline,
+            FunctionExpression: checkInline,
+            ArrowFunctionExpression: checkInline,
+        };
+    },
+});

package/dist/rules/statement-spacing.d.ts

@@ -0,0 +1 @@
+export declare const statementSpacing: import("@oxlint/plugins").Rule;