@mionjs/devtools 0.8.7 → 0.8.10

package/src/eslint/rules/no-typeof-runtype.ts

@@ -0,0 +1,112 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';
+
+/**
+ * Recursively checks if a type node contains `typeof`.
+ * @param typeNode The type node to check.
+ * @returns True if `typeof` is found, otherwise false.
+ */
+function containsTypeof(typeNode: TSESTree.Node | null): boolean {
+    if (!typeNode) return false;
+
+    switch (typeNode.type) {
+        case AST_NODE_TYPES.TSTypeQuery:
+            return true;
+        case AST_NODE_TYPES.TSUnionType:
+        case AST_NODE_TYPES.TSIntersectionType:
+            return typeNode.types.some(containsTypeof);
+        case AST_NODE_TYPES.TSTupleType:
+            return typeNode.elementTypes.some(containsTypeof);
+        default:
+            return false;
+    }
+}
+
+/**
+ * Checks if a call expression is calling runType or related functions from @mionjs/run-types
+ * @param node The call expression node
+ * @param context The ESLint context
+ * @returns True if it's a runType or related function call from @mionjs/run-types
+ */
+function isRunTypeFromMionKit(node: TSESTree.CallExpression, context: TSESLint.RuleContext<any, any>): boolean {
+    // List of functions that should not use typeof
+    const runTypeFunctions = ['runType', 'isTypeFn', 'typeErrorsFn', 'mockTypeFn', 'toJavascriptFn'];
+
+    // Check if the callee is an identifier with one of the runType function names
+    if (node.callee.type !== AST_NODE_TYPES.Identifier || !runTypeFunctions.includes(node.callee.name)) {
+        return false;
+    }
+
+    // Get the source code to check imports
+    const sourceCode = context.sourceCode;
+    const program = sourceCode.ast;
+
+    // Look for import statements that import runType or related functions from @mionjs/run-types or relative paths
+    for (const statement of program.body) {
+        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {
+            const source = statement.source.value;
+            // Check for @mionjs/run-types package or relative imports that end with runType or runTypeFunctions
+            if (
+                source === '@mionjs/run-types' ||
+                source === '@mionjs/run-types/' ||
+                (typeof source === 'string' && (source.endsWith('/runType') || source.endsWith('/runTypeFunctions')))
+            ) {
+                // Check if any of the runType functions are imported
+                for (const specifier of statement.specifiers) {
+                    if (
+                        specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === AST_NODE_TYPES.Identifier &&
+                        runTypeFunctions.includes(specifier.imported.name)
+                    ) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
+const rule: TSESLint.RuleModule<'noTypeof', []> = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow using `typeof` with run-type functions from @mionjs/run-types',
+        },
+        messages: {
+            noTypeof: 'Do not use `typeof` with `{{functionName}}()`. Use explicit type definitions instead.',
+        },
+        schema: [], // No options
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            CallExpression(node: TSESTree.CallExpression) {
+                // Ensure the function being called is a run-type function from @mionjs/run-types
+                if (isRunTypeFromMionKit(node, context)) {
+                    // Check if type arguments contain typeof
+                    const typeArguments = (node as any).typeArguments || (node as any).typeParameters;
+                    if (typeArguments?.params.some(containsTypeof)) {
+                        const functionName = (node.callee as TSESTree.Identifier).name;
+                        context.report({
+                            node,
+                            messageId: 'noTypeof',
+                            data: {
+                                functionName,
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+
+export default rule;

package/src/eslint/rules/no-unreachable-union-types.ts

@@ -0,0 +1,357 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';
+
+type PropertyInfo = {
+    name: string;
+    isOptional: boolean;
+};
+
+/**
+ * Extracts property names from an object type (interface body, type literal)
+ */
+function getObjectTypeProperties(node: TSESTree.TypeNode): PropertyInfo[] | null {
+    if (node.type === AST_NODE_TYPES.TSTypeLiteral) {
+        const props: PropertyInfo[] = [];
+        for (const member of node.members) {
+            if (member.type === AST_NODE_TYPES.TSPropertySignature && member.key.type === AST_NODE_TYPES.Identifier) {
+                props.push({name: member.key.name, isOptional: !!member.optional});
+            }
+        }
+        return props;
+    }
+    return null;
+}
+
+/**
+ * Checks if typeB (earlier in union) blocks typeA (later in union), making typeA unreachable.
+ *
+ * TypeB blocks TypeA when:
+ * - All properties of TypeB (required + optional) exist in TypeA
+ * - TypeA has at least as many required properties as TypeB
+ * - TypeA is more specific than TypeB (more properties OR same properties but more required)
+ *
+ * Examples:
+ * - {a: string} blocks {a: string; b: number} - TypeB has 'a' (req), TypeA has 'a' (req) + 'b' (req)
+ * - {a?: string} does NOT block {b: number; c: string} - TypeB has 'a', TypeA doesn't have 'a'
+ * - {a: string; b?: number} blocks {a: string; b: number} - same props, but TypeA has more required
+ *
+ * @param typeAProps - Properties of the later type (potentially unreachable)
+ * @param typeBProps - Properties of the earlier type (potentially blocking)
+ * @returns true if typeB blocks typeA
+ */
+function isSupersetOf(typeAProps: PropertyInfo[], typeBProps: PropertyInfo[]): boolean {
+    const typeARequired = typeAProps.filter((p) => !p.isOptional);
+    const typeBRequired = typeBProps.filter((p) => !p.isOptional);
+
+    // TypeA must have at least as many required properties as TypeB
+    if (typeARequired.length < typeBRequired.length) return false;
+
+    // TypeA must be more specific: either more properties OR same properties but more required
+    const isMoreSpecific =
+        typeAProps.length > typeBProps.length ||
+        (typeAProps.length === typeBProps.length && typeARequired.length > typeBRequired.length);
+
+    if (!isMoreSpecific) return false;
+
+    // Check if ALL properties of TypeB (required and optional) exist in TypeA
+    for (const propB of typeBProps) {
+        const propA = typeAProps.find((p) => p.name === propB.name);
+        // If TypeB has a prop that TypeA doesn't have, B doesn't block A
+        if (!propA) return false;
+    }
+
+    // TypeA has all properties of TypeB and is more specific, so TypeB blocks TypeA
+    return true;
+}
+
+/**
+ * Checks if a union type has interfaces where one is a superset of another
+ * and the subset comes before the superset (making the superset unreachable)
+ */
+function findUnreachableTypes(unionNode: TSESTree.TSUnionType): {unreachable: TSESTree.TypeNode; blocker: TSESTree.TypeNode}[] {
+    const issues: {unreachable: TSESTree.TypeNode; blocker: TSESTree.TypeNode}[] = [];
+    const typesWithProps: {node: TSESTree.TypeNode; props: PropertyInfo[]}[] = [];
+
+    // Collect all object types with their properties
+    for (const typeNode of unionNode.types) {
+        const props = getObjectTypeProperties(typeNode);
+        if (props && props.length > 0) {
+            typesWithProps.push({node: typeNode, props});
+        }
+    }
+
+    // For each pair of types, check if one is a superset of another
+    for (let i = 0; i < typesWithProps.length; i++) {
+        for (let j = i + 1; j < typesWithProps.length; j++) {
+            const typeA = typesWithProps[i];
+            const typeB = typesWithProps[j];
+
+            // If typeA (earlier) is a subset of typeB (later), typeB is unreachable
+            if (isSupersetOf(typeB.props, typeA.props)) {
+                issues.push({unreachable: typeB.node, blocker: typeA.node});
+            }
+        }
+    }
+
+    return issues;
+}
+
+/**
+ * Gets a readable representation of an object type for error messages
+ */
+function getTypeDescription(node: TSESTree.TypeNode): string {
+    if (node.type === AST_NODE_TYPES.TSTypeLiteral) {
+        const props = getObjectTypeProperties(node);
+        if (props) {
+            return `{${props.map((p) => (p.isOptional ? `${p.name}?` : p.name)).join(', ')}}`;
+        }
+    }
+    return 'object type';
+}
+
+/**
+ * Gets the router function name if the function is a handler for route/middleFn/headersFn
+ */
+function getRouterFunctionName(
+    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration,
+    context: TSESLint.RuleContext<any, any>
+): string | null {
+    const parent = func.parent;
+    if (parent?.type === AST_NODE_TYPES.CallExpression) {
+        if (parent.callee.type === AST_NODE_TYPES.Identifier) {
+            const functionName = parent.callee.name;
+            if (['route', 'middleFn', 'headersFn'].includes(functionName) && isImportedFromMionRouter(functionName, context)) {
+                return functionName;
+            }
+        }
+    }
+    return null;
+}
+
+/**
+ * Checks if the union type or type reference is in a parameter that should be checked
+ */
+function isInCheckableParameter(
+    node: TSESTree.TSUnionType | TSESTree.TSTypeReference,
+    func: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration,
+    routerFunctionName: string
+): boolean {
+    // Find which parameter contains this union type
+    let current: TSESTree.Node | undefined = node.parent;
+    while (current && current !== func) {
+        // Check if we're in a parameter
+        if (
+            current.type === AST_NODE_TYPES.Identifier ||
+            current.type === AST_NODE_TYPES.ArrayPattern ||
+            current.type === AST_NODE_TYPES.ObjectPattern
+        ) {
+            const paramIndex = func.params.indexOf(current as TSESTree.Parameter);
+            if (paramIndex !== -1) {
+                // For route and middleFn: skip first parameter (context)
+                if ((routerFunctionName === 'route' || routerFunctionName === 'middleFn') && paramIndex >= 1) {
+                    return true;
+                }
+                // For headersFn: skip first two parameters (context and headers)
+                if (routerFunctionName === 'headersFn' && paramIndex >= 2) {
+                    return true;
+                }
+                return false;
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
+
+/**
+ * Checks if the union type or type reference is a return type or parameter type of route/middleFn/headersFn
+ */
+function isRouterUnionType(
+    node: TSESTree.TSUnionType | TSESTree.TSTypeReference,
+    context: TSESLint.RuleContext<any, any>
+): boolean {
+    // Check if we're in a return type annotation or parameter type annotation
+    let current: TSESTree.Node | undefined = node.parent;
+    while (current) {
+        // Check if we're in a function that's used in route/middleFn/headersFn
+        if (
+            current.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+            current.type === AST_NODE_TYPES.FunctionExpression ||
+            current.type === AST_NODE_TYPES.FunctionDeclaration
+        ) {
+            const routerFunctionName = getRouterFunctionName(current, context);
+            if (routerFunctionName) {
+                // Check if we're in the return type
+                if (current.returnType?.typeAnnotation === node || isDescendantOf(node, current.returnType?.typeAnnotation)) {
+                    return true;
+                }
+                // Check if we're in a parameter type (excluding context and headers params)
+                if (isInCheckableParameter(node, current, routerFunctionName)) {
+                    return true;
+                }
+            }
+        }
+        // Check if we're in a type annotation for Handler/HeaderHandler
+        if (current.type === AST_NODE_TYPES.TSTypeAnnotation) {
+            const typeAnnotationParent = current.parent;
+            if (typeAnnotationParent?.type === AST_NODE_TYPES.Identifier) {
+                const declarator = typeAnnotationParent.parent;
+                if (declarator?.type === AST_NODE_TYPES.VariableDeclarator) {
+                    // Check if the type annotation references Handler/HeaderHandler
+                    if (current.typeAnnotation.type === AST_NODE_TYPES.TSTypeReference) {
+                        const typeName = current.typeAnnotation.typeName;
+                        if (typeName.type === AST_NODE_TYPES.Identifier) {
+                            if (
+                                (typeName.name === 'Handler' || typeName.name === 'HeaderHandler') &&
+                                isImportedFromMionRouter(typeName.name, context)
+                            ) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+}
+
+/**
+ * Checks if a node is a descendant of another node
+ */
+function isDescendantOf(node: TSESTree.Node | undefined, ancestor: TSESTree.Node | undefined): boolean {
+    if (!node || !ancestor) return false;
+    let current: TSESTree.Node | undefined = node;
+    while (current) {
+        if (current === ancestor) return true;
+        current = current.parent;
+    }
+    return false;
+}
+
+/**
+ * Checks if a name is imported from @mionjs/router
+ */
+function isImportedFromMionRouter(name: string, context: TSESLint.RuleContext<any, any>): boolean {
+    const sourceCode = context.sourceCode;
+    const program = sourceCode.ast;
+
+    for (const statement of program.body) {
+        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {
+            const source = statement.source.value;
+            if (source === '@mionjs/router' || source === '@mionjs/router/') {
+                for (const specifier of statement.specifiers) {
+                    if (
+                        specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+                        specifier.imported.type === AST_NODE_TYPES.Identifier &&
+                        specifier.imported.name === name
+                    ) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Resolves a type reference to its actual union type definition
+ */
+function resolveTypeReference(node: TSESTree.TypeNode, context: TSESLint.RuleContext<any, any>): TSESTree.TSUnionType | null {
+    if (node.type !== AST_NODE_TYPES.TSTypeReference) {
+        return null;
+    }
+
+    // Get the type name
+    if (node.typeName.type !== AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+
+    const typeName = node.typeName.name;
+    const sourceCode = context.sourceCode;
+    const program = sourceCode.ast;
+
+    // Find the type alias declaration
+    for (const statement of program.body) {
+        if (statement.type === AST_NODE_TYPES.TSTypeAliasDeclaration) {
+            if (statement.id.name === typeName && statement.typeAnnotation.type === AST_NODE_TYPES.TSUnionType) {
+                return statement.typeAnnotation;
+            }
+        }
+    }
+
+    return null;
+}
+
+const rule: TSESLint.RuleModule<'unreachableUnionType', []> = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description:
+                'Detect union types where one interface is unreachable at runtime when using isType function because a subset type comes before it',
+        },
+        messages: {
+            unreachableUnionType:
+                'Union type {{unreachableType}} is unreachable at runtime when doing type checking because {{blockerType}} will always match first. ' +
+                'To fix this move the more specific type {{unreachableType}} first within the union, ie: {{unreachableType}} | {{blockerType}} ',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            TSUnionType(node: TSESTree.TSUnionType) {
+                // Only check unions in router context
+                if (!isRouterUnionType(node, context)) {
+                    return;
+                }
+
+                const issues = findUnreachableTypes(node);
+                for (const issue of issues) {
+                    context.report({
+                        node: node,
+                        messageId: 'unreachableUnionType',
+                        data: {
+                            unreachableType: getTypeDescription(issue.unreachable),
+                            blockerType: getTypeDescription(issue.blocker),
+                        },
+                    });
+                }
+            },
+            TSTypeReference(node: TSESTree.TSTypeReference) {
+                // Try to resolve the type reference to a union type
+                const unionType = resolveTypeReference(node, context);
+                if (!unionType) {
+                    return;
+                }
+
+                // Only check if this type reference is used in a router context
+                if (!isRouterUnionType(node, context)) {
+                    return;
+                }
+
+                const issues = findUnreachableTypes(unionType);
+                for (const issue of issues) {
+                    context.report({
+                        node: node,
+                        messageId: 'unreachableUnionType',
+                        data: {
+                            unreachableType: getTypeDescription(issue.unreachable),
+                            blockerType: getTypeDescription(issue.blocker),
+                        },
+                    });
+                }
+            },
+        };
+    },
+};
+
+export default rule;

package/src/eslint/rules/no-vite-client.ts

@@ -0,0 +1,101 @@
+/* ########
+ * 2026 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {TSESTree, TSESLint, AST_NODE_TYPES} from '@typescript-eslint/utils';
+import {PURE_FN_SOURCE_PACKAGES} from '../../pureFns/purityRules.ts';
+
+type MessageIds = 'missingPureFnName' | 'missingMapFromName' | 'nameNotStringLiteral' | 'registerPureFnFactoryNotAllowed';
+
+/** Enforces non-Vite client constraints: requires names for pureServerFn/mapFrom and disallows registerPureFnFactory */
+const rule: TSESLint.RuleModule<MessageIds, []> = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description:
+                'Enforce non-Vite client constraints: require name/bodyHash string literal for pureServerFn() and mapFrom(), and disallow registerPureFnFactory() which requires Vite transforms.',
+        },
+        messages: {
+            missingPureFnName:
+                'pureServerFn() requires a name as the second argument (string literal) for non-Vite environments.',
+            missingMapFromName: 'mapFrom() requires a name as the third argument (string literal) for non-Vite environments.',
+            nameNotStringLiteral: '{{callee}}() name argument must be a string literal, not a variable or expression.',
+            registerPureFnFactoryNotAllowed:
+                'registerPureFnFactory() is not supported in non-Vite environments. It requires Vite build-time transforms.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        let pureFnNames: Map<string, string> | null = null;
+
+        return {
+            Program(node: TSESTree.Program) {
+                pureFnNames = new Map();
+                for (const statement of node.body) {
+                    if (statement.type !== AST_NODE_TYPES.ImportDeclaration) continue;
+                    const source = statement.source.value;
+                    if (!PURE_FN_SOURCE_PACKAGES.includes(source as (typeof PURE_FN_SOURCE_PACKAGES)[number])) continue;
+
+                    for (const specifier of statement.specifiers) {
+                        if (
+                            specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.imported.type === AST_NODE_TYPES.Identifier
+                        ) {
+                            const importedName = specifier.imported.name;
+                            if (
+                                importedName === 'pureServerFn' ||
+                                importedName === 'mapFrom' ||
+                                importedName === 'registerPureFnFactory'
+                            ) {
+                                pureFnNames.set(specifier.local.name, importedName);
+                            }
+                        }
+                    }
+                }
+            },
+
+            CallExpression(node: TSESTree.CallExpression) {
+                if (!pureFnNames || pureFnNames.size === 0) return;
+                if (node.callee.type !== AST_NODE_TYPES.Identifier) return;
+                const importedName = pureFnNames.get(node.callee.name);
+                if (!importedName) return;
+
+                if (importedName === 'pureServerFn') {
+                    if (node.arguments.length < 2) {
+                        context.report({node, messageId: 'missingPureFnName'});
+                    } else if (
+                        node.arguments[1].type !== AST_NODE_TYPES.Literal ||
+                        typeof (node.arguments[1] as TSESTree.Literal).value !== 'string'
+                    ) {
+                        context.report({
+                            node: node.arguments[1],
+                            messageId: 'nameNotStringLiteral',
+                            data: {callee: 'pureServerFn'},
+                        });
+                    }
+                } else if (importedName === 'mapFrom') {
+                    if (node.arguments.length < 3) {
+                        context.report({node, messageId: 'missingMapFromName'});
+                    } else if (
+                        node.arguments[2].type !== AST_NODE_TYPES.Literal ||
+                        typeof (node.arguments[2] as TSESTree.Literal).value !== 'string'
+                    ) {
+                        context.report({
+                            node: node.arguments[2],
+                            messageId: 'nameNotStringLiteral',
+                            data: {callee: 'mapFrom'},
+                        });
+                    }
+                } else if (importedName === 'registerPureFnFactory') {
+                    context.report({node, messageId: 'registerPureFnFactoryNotAllowed'});
+                }
+            },
+        };
+    },
+};
+
+export default rule;