Would oxlint accept a contribution for a ts-enum-util lint?

[bes]

Hello!

At our company we use the ts-enum-util library alot, and we have a custom eslint rule enforce-ts-enum-util-handle-unexpected, which warns if you forget to handle the unexpected case.

• Would oxlint accept a contribution for this rule written in Rust?
• What plugin would be most suitable in that case?

Thanks!

[camc314]

enforce-ts-enum-util-handle-unexpected

Can you explain more about this rule? what are examples of what it does? Does it require type information? What are the cases is reports diagnostics on/ what cases does it pass?

This infomation will allow us to make an informed decisiont - thanks

[bes]

Basically, if you model your API using enums to discriminate polymorphic types, you might have something that looks like this

enum MessageType { A = "a", B = "b" }
$enum.mapValue(alert.messageType).with({
    [MessageType.A]: "It was variant a",
    [MessageType.B]: "It was variant b",
    [$enum.handleUnexpected]: "Unexpected!"
})

So basically in this example, if we get an enum value from our backend that is of a later version, which contains a value C = "c" then it will be handled by the special $enum.handleUnexpected from ts-enum-util.

If the handleUnexpected handler is missing, we have seen some varying behavior in practice, including crashes.

This is what we model in our custom eslint plugin.

Basically the question is; should we keep running this as a JS plugin through oxlint or is it something you are interested in?

[bes]

Currently, this is the whole plugin.

Code

import { ESLintUtils, type TSESTree } from "@typescript-eslint/utils";

const createRule = ESLintUtils.RuleCreator(
    (name) => `https://gitlab.com/spiideo/frontend/spiideo-eslint/-/blob/main/docs/rules/${name}.md`,
);

/**
 * Currently, this is a relatively naive lint that checks that the names/symbols `$enum.mapValue(x).with(...` line up,
 * but it will not find any match if the code uses another symbol than `$enum`.
 */
export const enforceTsEnumUtilHandleUnexpected = createRule({
    name: "enforce-ts-enum-util-handle-unexpected",
    meta: {
        type: "problem",
        docs: {
            description:
                "Enforce that ts-enum-util $enum.mapValue().with() always includes [$enum.handleUnexpected] handler",
        },
        messages: {
            missingHandleUnexpected:
                "Missing [$enum.handleUnexpected] handler in $enum.mapValue().with() call. Add it to prevent runtime crashes on unexpected enum values.",
        },
        schema: [],
    },
    defaultOptions: [],
    create(context) {
        return {
            CallExpression(node: TSESTree.CallExpression) {
                // Check if this is an expression like "x.funcName"
                if (node.callee.type !== "MemberExpression") {
                    return;
                }

                // Get the callee of the expression, the "funcName" part
                const memberExpr = node.callee;

                // Check if the callee is "with"
                if (memberExpr.property.type !== "Identifier" || memberExpr.property.name !== "with") {
                    return;
                }

                // Check if the object is a call to $enum.mapValue()
                if (memberExpr.object.type !== "CallExpression") {
                    return;
                }

                const mapValueCall = memberExpr.object;

                // Check if this is a call to .mapValue()
                if (mapValueCall.callee.type !== "MemberExpression") {
                    return;
                }

                const mapValueMember = mapValueCall.callee;

                // Check if the property is "mapValue"
                if (mapValueMember.property.type !== "Identifier" || mapValueMember.property.name !== "mapValue") {
                    return;
                }

                // Check if the object is $enum
                if (mapValueMember.object.type !== "Identifier" || mapValueMember.object.name !== "$enum") {
                    return;
                }

                // At this point, we've confirmed this is $enum.mapValue(...).with(...)
                // Now check if the first argument to .with() is an object expression
                if (node.arguments.length === 0) {
                    context.report({
                        node,
                        messageId: "missingHandleUnexpected",
                    });
                    return;
                }

                const firstArg = node.arguments[0];
                if (firstArg.type !== "ObjectExpression") {
                    return;
                }

                // Check if the object has a [$enum.handleUnexpected] property
                const hasHandleUnexpected = firstArg.properties.some((prop) => {
                    // We're looking for a computed property with key $enum.handleUnexpected
                    if (prop.type !== "Property") {
                        return false;
                    }

                    // Must be a computed property, i.e., [key]
                    if (!prop.computed) {
                        return false;
                    }

                    // Check if the key is a MemberExpression for $enum.handleUnexpected
                    if (prop.key.type !== "MemberExpression") {
                        return false;
                    }

                    const keyMember = prop.key;

                    // Check if it's $enum.handleUnexpected
                    return (
                        keyMember.object.type === "Identifier" &&
                        keyMember.object.name === "$enum" &&
                        keyMember.property.type === "Identifier" &&
                        keyMember.property.name === "handleUnexpected"
                    );
                });

                if (!hasHandleUnexpected) {
                    context.report({
                        node,
                        messageId: "missingHandleUnexpected",
                    });
                }
            },
        };
    },
});