oxlint-plugin-arch 0.2.1

package/src/utils/helpers/orpc.ts

@@ -0,0 +1,31 @@
+import { astStaticMemberName } from './ast.ts'
+import type { ESTree } from '@oxlint/plugins'
+
+export function orpcFindChainCall(expression: ESTree.Expression, method: string): ESTree.CallExpression | undefined {
+  if (expression.type === 'CallExpression') {
+    if (expression.callee.type === 'MemberExpression' && astStaticMemberName(expression.callee) === method) {
+      return expression
+    }
+
+    if (expression.callee.type === 'MemberExpression') {
+      return orpcFindChainCall(expression.callee.object, method)
+    }
+  }
+
+  if (expression.type === 'MemberExpression') {
+    return orpcFindChainCall(expression.object, method)
+  }
+
+  if (expression.type === 'ChainExpression') {
+    return orpcFindChainCall(expression.expression, method)
+  }
+}
+
+export function orpcIsNamedOrComposedArgument(argument: ESTree.Argument | undefined, composers: Set<string>): boolean {
+  if (argument?.type === 'Identifier') {
+    return true
+  }
+
+  return argument?.type === 'CallExpression' && argument.callee.type === 'Identifier'
+    && composers.has(argument.callee.name) && argument.arguments[0]?.type === 'Identifier'
+}

package/src/utils/helpers/react-components.ts

@@ -0,0 +1,146 @@
+import {
+  astCallName,
+  astContainsJsx,
+  astDirectReturnExpressions,
+  astNearestFunction,
+  astVisit,
+} from './ast.ts'
+import { exportsCollect } from './exports.ts'
+import type { AstRuntimeFunction } from './ast.ts'
+import type { ESTree } from '@oxlint/plugins'
+
+export interface ReactComponentsCandidate {
+  name: string
+  node: ESTree.Node
+  declaration?: ESTree.Declaration
+  initializer?: ESTree.Expression | null
+  typeOnly?: boolean
+}
+
+export function reactComponentsExportCandidates(program: ESTree.Program): ReactComponentsCandidate[] {
+  return exportsCollect(program).map((binding) => ({
+    ...binding,
+    name: binding.localName ?? binding.exportedName,
+  }))
+}
+
+function importedPropsWithChildren(program: ESTree.Program): Set<string> {
+  return new Set(program.body.flatMap((statement) => statement.type === 'ImportDeclaration'
+    && statement.source.value === 'react'
+    ? statement.specifiers.flatMap((specifier) => specifier.type === 'ImportSpecifier'
+      && specifier.imported.type === 'Identifier'
+      && specifier.imported.name === 'PropsWithChildren'
+      ? [specifier.local.name]
+      : [])
+    : []))
+}
+
+function containsNamedTypeReference(node: unknown, names: Set<string>): boolean {
+  let found = false
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === 'TSTypeReference'
+      && candidate.typeName.type === 'Identifier'
+      && names.has(candidate.typeName.name)) {
+      found = true
+    }
+  })
+
+  return found
+}
+
+function returnsReactChildren(program: ESTree.Program, node: AstRuntimeFunction, expressions: ESTree.Expression[]): boolean {
+  const returnedNames = new Set(expressions.flatMap((expression) => expression.type === 'Identifier' ? [expression.name] : []))
+  const propsWithChildren = importedPropsWithChildren(program)
+
+  return node.params.some((param) => {
+    if (param.type !== 'ObjectPattern') {
+      return false
+    }
+
+    const returnsChild = param.properties.some((property) => property.type === 'Property'
+      && property.value.type === 'Identifier'
+      && returnedNames.has(property.value.name))
+    return returnsChild && containsNamedTypeReference(param.typeAnnotation, propsWithChildren)
+  })
+}
+
+export function reactComponentsFunctionReturnsOutput(program: ESTree.Program, node: AstRuntimeFunction): boolean {
+  const expressions = astDirectReturnExpressions(node)
+  return expressions.some((expression) => astContainsJsx(expression) || (expression.type === 'Literal' && expression.value === null))
+    || returnsReactChildren(program, node, expressions)
+}
+
+function functionReturnsLocalComponent(program: ESTree.Program, node: ESTree.Function): boolean {
+  const componentNames = new Set<string>()
+  astVisit(node.body, [node], (candidate, ancestors) => {
+    if (candidate.type === 'FunctionDeclaration'
+      && candidate !== node
+      && candidate.id?.name
+      && /^[A-Z]/.test(candidate.id.name)
+      && astNearestFunction(ancestors) === node
+      && reactComponentsFunctionReturnsOutput(program, candidate)) {
+      componentNames.add(candidate.id.name)
+    }
+  })
+
+  return astDirectReturnExpressions(node)
+    .some((expression) => expression.type === 'Identifier' && componentNames.has(expression.name))
+}
+
+function componentFactoryNames(program: ESTree.Program): Set<string> {
+  return new Set(program.body.flatMap((statement) => statement.type === 'FunctionDeclaration'
+    && statement.id?.name
+    && functionReturnsLocalComponent(program, statement)
+    ? [statement.id.name]
+    : []))
+}
+
+function isComponentInitializer(program: ESTree.Program, initializer: ESTree.Expression | null | undefined): boolean {
+  if (!initializer) {
+    return false
+  }
+
+  if (initializer.type === 'ArrowFunctionExpression' || initializer.type === 'FunctionExpression') {
+    return reactComponentsFunctionReturnsOutput(program, initializer)
+  }
+
+  if (initializer.type !== 'CallExpression') {
+    return false
+  }
+
+  const name = astCallName(initializer)
+
+  if (name === 'forwardRef' || name === 'memo') {
+    return initializer.arguments.some((argument) => argument.type !== 'SpreadElement' && isComponentInitializer(program, argument))
+  }
+
+  if (name === 'lazy') {
+    return initializer.arguments.some((argument) => argument.type === 'ArrowFunctionExpression' || argument.type === 'FunctionExpression')
+  }
+
+  return Boolean(name?.startsWith('create') && componentFactoryNames(program).has(name))
+}
+
+export function reactComponentsIsLike(program: ESTree.Program, candidate: ReactComponentsCandidate): boolean {
+  if (!/^[A-Z]/.test(candidate.name)) {
+    return false
+  }
+
+  const declaration = candidate.declaration ?? candidate.node
+
+  if (declaration.type === 'FunctionDeclaration') {
+    return reactComponentsFunctionReturnsOutput(program, declaration)
+  }
+
+  return declaration.type === 'VariableDeclaration'
+    && isComponentInitializer(program, candidate.initializer)
+}
+
+export function reactComponentsPascalFromBasename(basename: string): string {
+  return basename
+    .replace(/\.(tsx?|jsx?)$/, '')
+    .split(/[-.]/)
+    .filter(Boolean)
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join('')
+}

package/src/utils/helpers/routes.ts

@@ -0,0 +1,31 @@
+import { astCallName, astVisit } from './ast.ts'
+import type { Context, ESTree } from '@oxlint/plugins'
+
+export function routesInspectFunction(
+  context: Context,
+  item: { name: string, node: ESTree.Function | ESTree.ArrowFunctionExpression },
+  bannedHooks: Set<string>,
+  banIntrinsicJsx: boolean,
+): void {
+  astVisit(item.node.body, [item.node], (node) => {
+    if (banIntrinsicJsx && node.type === 'JSXOpeningElement' && node.name.type === 'JSXIdentifier' && /^[a-z]/.test(node.name.name)) {
+      context.report({
+        node,
+        messageId: 'hostJsx',
+        data: { name: item.name },
+      })
+    }
+
+    if (node.type === 'CallExpression') {
+      const name = astCallName(node)
+
+      if (name && bannedHooks.has(name)) {
+        context.report({
+          node,
+          messageId: 'bannedHook',
+          data: { hook: name, name: item.name },
+        })
+      }
+    }
+  })
+}

package/src/utils/helpers/sanitizers.ts

@@ -0,0 +1,33 @@
+import { astVisit } from './ast.ts'
+import type { ESTree } from '@oxlint/plugins'
+
+export function sanitizersCallsConfigured(node: unknown, names: Set<string>): boolean {
+  let found = false
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === 'CallExpression' && candidate.callee.type === 'Identifier' && names.has(candidate.callee.name)) {
+      found = true
+    }
+  })
+
+  return found
+}
+
+export function sanitizersConfiguredBindings(program: ESTree.Program, names: Set<string>): Set<string> {
+  const result = new Set<string>()
+
+  for (const statement of program.body) {
+    const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement
+
+    if (declaration?.type !== 'VariableDeclaration') {
+      continue
+    }
+
+    for (const item of declaration.declarations) {
+      if (item.id.type === 'Identifier' && sanitizersCallsConfigured(item.init, names)) {
+        result.add(item.id.name)
+      }
+    }
+  }
+
+  return result
+}

package/src/utils/helpers/schemas.ts

@@ -0,0 +1,82 @@
+import { astStaticMemberName } from './ast.ts'
+import type { ESTree } from '@oxlint/plugins'
+
+function schemasIsRuntimeSpecifier(specifier: ESTree.ImportDeclarationSpecifier): boolean {
+  return specifier.type !== 'ImportSpecifier' || specifier.importKind !== 'type'
+}
+
+function schemasMemberRootName(node: ESTree.MemberExpression): string | undefined {
+  if (node.object.type === 'Identifier') {
+    return node.object.name
+  }
+
+  return node.object.type === 'MemberExpression' ? schemasMemberRootName(node.object) : undefined
+}
+
+export function schemasIsPackage(source: string, packages: ReadonlySet<string>): boolean {
+  return packages.has(source) || [...packages].some((pkg) => source.startsWith(`${pkg}/`))
+}
+
+export function schemasIsCall(node: ESTree.CallExpression, namespaces: Set<string>): boolean {
+  return node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && namespaces.has(node.callee.object.name)
+}
+
+export function schemasRuntimeImportLocals(node: ESTree.ImportDeclaration): string[] {
+  return node.importKind === 'type'
+    ? []
+    : node.specifiers.flatMap((specifier) => schemasIsRuntimeSpecifier(specifier) ? [specifier.local.name] : [])
+}
+
+export function schemasIsRuntimeImport(node: ESTree.ImportDeclaration, packages: ReadonlySet<string>): boolean {
+  return schemasIsPackage(node.source.value, packages)
+    && (node.specifiers.length === 0 ? node.importKind !== 'type' : schemasRuntimeImportLocals(node).length > 0)
+}
+
+export function schemasIsRuntimeReexport(node: ESTree.ExportNamedDeclaration | ESTree.ExportAllDeclaration, packages: ReadonlySet<string>): boolean {
+  if (!node.source || !schemasIsPackage(node.source.value, packages) || node.exportKind === 'type') {
+    return false
+  }
+
+  return node.type === 'ExportAllDeclaration'
+    || node.specifiers.length === 0
+    || node.specifiers.some((specifier) => specifier.exportKind !== 'type')
+}
+
+export function schemasIsConstruction(node: ESTree.CallExpression, constructors: ReadonlySet<string>): boolean {
+  if (node.callee.type === 'Identifier') {
+    return constructors.has(node.callee.name)
+  }
+
+  if (node.callee.type !== 'MemberExpression') {
+    return false
+  }
+
+  const root = schemasMemberRootName(node.callee)
+  return Boolean(root && constructors.has(root))
+}
+
+export function schemasElements(node: ESTree.CallExpression): ESTree.Argument[] {
+  return node.arguments.flatMap((argument) => argument.type === 'ArrayExpression'
+    ? argument.elements.filter((element): element is Exclude<ESTree.ArrayExpressionElement, null> => element !== null)
+    : [argument])
+}
+
+export function schemasIsAllowedElement(node: ESTree.Argument, allowScalars: boolean, namespaces: Set<string>, structuralMethods: Set<string>): boolean {
+  if (node.type === 'Identifier') {
+    return true
+  }
+
+  if (!allowScalars || node.type !== 'CallExpression' || !schemasIsCall(node, namespaces)) {
+    return false
+  }
+
+  const name = node.callee.type === 'MemberExpression' ? astStaticMemberName(node.callee) : undefined
+  return Boolean(name && !structuralMethods.has(name))
+}
+
+export function schemasTypeOperator(node: ESTree.TSTypeReference, namespaces: Set<string>, operators: Set<string>): string | undefined {
+  return node.typeName.type === 'TSQualifiedName' && node.typeName.left.type === 'Identifier'
+    && namespaces.has(node.typeName.left.name) && operators.has(node.typeName.right.name)
+    ? node.typeName.right.name
+    : undefined
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './helpers/index.ts'