oxlint-plugin-arch 0.5.0 → 0.6.0

package/dist/rules/module-policy/index.js

@@ -1211,7 +1211,13 @@ import { defineRule as defineRule5 } from "@oxlint/plugins";
 var testModifiers = defineRule5({
   meta: {
     type: "problem",
-    schema: [],
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: { additionalTestFunctions: { type: "array", items: { type: "string" } } }
+      }
+    ],
     messages: {
       modifier: "Focused, skipped and placeholder tests are not allowed."
     }
@@ -1220,7 +1226,13 @@ var testModifiers = defineRule5({
     let names = new Set;
     return {
       before() {
-        names = new Set(["test", "it", "describe", "suite"]);
+        names = new Set([
+          "test",
+          "it",
+          "describe",
+          "suite",
+          ...optionsFirst(context, {}).additionalTestFunctions ?? []
+        ]);
       },
       ImportDeclaration(node) {
         if (!["vitest", "bun:test", "@playwright/test", "@jest/globals"].includes(node.source.value)) {
@@ -1242,7 +1254,7 @@ var testModifiers = defineRule5({
           return;
         }
         const parts = name.split(".");
-        if (names.has(parts[0]) && ["only", "skip", "todo"].includes(parts.at(-1) ?? "")) {
+        if ([...names].some((test) => name.startsWith(test + ".")) && ["only", "skip", "todo"].includes(parts.at(-1) ?? "")) {
           context.report({ node, messageId: "modifier" });
         }
       }
@@ -1250,9 +1262,306 @@ var testModifiers = defineRule5({
   }
 });
 
-// src/rules/module-policy/reasoned-directives.ts
+// src/rules/module-policy/test-assertions.ts
 import { defineRule as defineRule6 } from "@oxlint/plugins";
-var directives = defineRule6({
+
+// src/constants/test.constants.ts
+var testAssertionFunctions = [
+  "expect",
+  "expect.poll",
+  "expect.soft",
+  "expect.assert",
+  "expect.assertions",
+  "expect.hasAssertions",
+  "expectTypeOf",
+  "assert",
+  "assertType"
+];
+
+// src/utils/helpers/test-tables.ts
+function testTablesRegistration(call, names, functions) {
+  let callee = call.callee;
+  let table;
+  if (callee.type === "CallExpression") {
+    const builder = astDottedName(callee.callee);
+    if (builder?.endsWith(".for") || builder?.endsWith(".each")) {
+      const argument = callee.arguments[0];
+      if (argument && argument.type !== "SpreadElement")
+        table = argument;
+    }
+    callee = callee.callee;
+  }
+  if (callee.type === "TaggedTemplateExpression")
+    callee = callee.tag;
+  const name = astDottedName(callee);
+  if (!name || !names.some((test) => name === test || name.startsWith(test + ".") && name.slice(test.length + 1).split(".").every((part) => ["for", "each", "concurrent", "sequential", "only", "skip"].includes(part))))
+    return;
+  const argument = call.arguments.at(-1);
+  const callback = argument?.type === "Identifier" ? functions.get(argument) : argument;
+  if (callback?.type === "FunctionDeclaration" || callback?.type === "FunctionExpression" || callback?.type === "ArrowFunctionExpression") {
+    return { call, callback, table };
+  }
+}
+function testTablesResolve(expression, values) {
+  const seen = new Set;
+  let value = trivialUnwrap(expression);
+  while (values.has(value) && !seen.has(value)) {
+    seen.add(value);
+    value = trivialUnwrap(values.get(value));
+  }
+  return value;
+}
+function testTablesRows(registration, sourceCode, values, functions) {
+  if (!registration.table)
+    return;
+  const table = testTablesResolve(registration.table, values);
+  if (table.type !== "ArrayExpression")
+    return;
+  const parameter = registration.callback.params[0];
+  const variables = sourceCode.getDeclaredVariables(registration.callback);
+  return table.elements.map((element) => {
+    const row = { bindings: new Map, callbacks: [] };
+    if (!element || element.type === "SpreadElement")
+      return row;
+    const value = testTablesResolve(element, values);
+    if (value.type !== "ObjectExpression" || value.properties.some((property) => property.type === "SpreadElement" || property.computed))
+      return row;
+    const properties = new Map;
+    for (const property of value.properties) {
+      if (property.type !== "Property" || property.kind !== "init")
+        continue;
+      const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : undefined;
+      if (!key)
+        continue;
+      properties.delete(key);
+      const expression = property.value;
+      const fn = functions.get(expression) ?? expression;
+      if (fn.type === "FunctionDeclaration" || fn.type === "FunctionExpression" || fn.type === "ArrowFunctionExpression")
+        properties.set(key, fn);
+    }
+    row.callbacks.push(...properties.values());
+    if (parameter?.type === "ObjectPattern") {
+      for (const property of parameter.properties) {
+        if (property.type !== "Property" || property.computed || property.value.type !== "Identifier")
+          continue;
+        const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : "";
+        const fn = properties.get(key);
+        if (!fn)
+          continue;
+        const variable = variables.find((entry) => entry.identifiers.some((identifier) => identifier === property.value));
+        for (const reference of variable?.references ?? [])
+          row.bindings.set(reference.identifier, fn);
+      }
+    } else if (parameter?.type === "Identifier") {
+      const variable = variables.find((entry) => entry.identifiers.includes(parameter));
+      for (const reference of variable?.references ?? []) {
+        const member = reference.identifier.parent;
+        if (member.type !== "MemberExpression" || member.object !== reference.identifier || member.computed || member.property.type !== "Identifier")
+          continue;
+        const fn = properties.get(member.property.name);
+        if (fn)
+          row.bindings.set(member, fn);
+      }
+    }
+    return row;
+  });
+}
+function testTablesCallName(node) {
+  if (node.type === "CallExpression")
+    return testTablesCallName(node.callee);
+  if (node.type === "Identifier")
+    return node.name;
+  if (node.type !== "MemberExpression" || node.computed || node.property.type !== "Identifier")
+    return;
+  const parent = testTablesCallName(node.object);
+  return parent ? `${parent}.${node.property.name}` : undefined;
+}
+function testTablesAssertionPattern(name) {
+  const parts = name.split(".");
+  const pattern = parts.map((part, index) => {
+    if (part === "**")
+      return "(?:\\.[^.]+)*";
+    return (index ? "\\." : "") + part.replaceAll("$", "\\$").replaceAll("*", "[^.]*");
+  }).join("");
+  return new RegExp(`^${pattern}$`);
+}
+
+// src/rules/module-policy/test-assertions.ts
+var testAssertions = defineRule6({
+  meta: {
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          additionalTestFunctions: { type: "array", items: { type: "string" } },
+          additionalAssertionFunctions: { type: "array", items: { type: "string" } }
+        }
+      }
+    ],
+    messages: {
+      missing: "This test has no recognized assertion in every case. Assert the result directly or call its assertion helper. Register imported assertion helpers only after verifying that they fail on incorrect results.",
+      standalone: "Put this assertion inside a test or an assertion helper. Table-row assertion callbacks must belong to a registered test."
+    }
+  },
+  createOnce(context) {
+    return {
+      "Program:exit"(program) {
+        const options = optionsFirst(context, {});
+        const tests = ["test", "it", ...options.additionalTestFunctions ?? []];
+        const functions = new Map;
+        const values = new Map;
+        const patterns = [
+          ...testAssertionFunctions,
+          "assert.*",
+          ...options.additionalAssertionFunctions ?? []
+        ].map(testTablesAssertionPattern);
+        const aliases = new Map;
+        const shadowed = new Set;
+        const calls = [];
+        const allowed = new Set;
+        const assertionRoots = new Set([...testAssertionFunctions, ...options.additionalAssertionFunctions ?? []].map((name) => name.split(".")[0]));
+        astVisit(program, [], (node) => {
+          if (node.type === "CallExpression")
+            calls.push(node);
+          if (![
+            "VariableDeclarator",
+            "FunctionDeclaration",
+            "FunctionExpression",
+            "ArrowFunctionExpression",
+            "ImportDeclaration"
+          ].includes(node.type))
+            return;
+          for (const variable of context.sourceCode.getDeclaredVariables(node)) {
+            const native = node.type === "ImportDeclaration" && ["vitest", "@jest/globals", "@playwright/test"].includes(node.source.value);
+            if (assertionRoots.has(variable.name) && node.type !== "ImportDeclaration") {
+              for (const reference of variable.references)
+                shadowed.add(reference.identifier);
+            }
+            if (native && node.type === "ImportDeclaration") {
+              const specifier = node.specifiers.find((entry) => entry.local.name === variable.name);
+              if (specifier?.type === "ImportSpecifier") {
+                const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+                if (["test", "it"].includes(imported))
+                  tests.push(variable.name);
+                if (assertionRoots.has(imported)) {
+                  for (const reference of variable.references)
+                    aliases.set(reference.identifier, imported);
+                }
+              }
+            }
+            const fn = node.type === "FunctionDeclaration" ? node : node.type === "VariableDeclarator" ? node.init : undefined;
+            if (fn?.type === "FunctionDeclaration" || fn?.type === "FunctionExpression" || fn?.type === "ArrowFunctionExpression") {
+              for (const reference of variable.references)
+                functions.set(reference.identifier, fn);
+              allowed.add(fn);
+            }
+            if (node.type === "VariableDeclarator" && node.init && node.parent.type === "VariableDeclaration" && node.parent.kind === "const") {
+              for (const reference of variable.references)
+                values.set(reference.identifier, node.init);
+            }
+          }
+        });
+        function assertionName(call) {
+          let root = call.callee;
+          while (root.type === "MemberExpression" || root.type === "CallExpression")
+            root = root.type === "MemberExpression" ? root.object : root.callee;
+          if (shadowed.has(root))
+            return;
+          const name = testTablesCallName(call.callee);
+          const alias = aliases.get(root);
+          return alias && name && root.type === "Identifier" ? alias + name.slice(root.name.length) : name;
+        }
+        function hasAssertion(fn, bindings, seen) {
+          if (seen.has(fn))
+            return false;
+          seen.add(fn);
+          let found = false;
+          astVisit(fn.body, [], (node, ancestors) => {
+            if (found || node.type !== "CallExpression")
+              return;
+            if (ancestors.some((ancestor) => ancestor.type === "FunctionDeclaration" || (ancestor.type === "FunctionExpression" || ancestor.type === "ArrowFunctionExpression") && ancestor.parent.type !== "CallExpression"))
+              return;
+            const name = assertionName(node);
+            if (name && patterns.some((pattern) => pattern.test(name)))
+              found = true;
+            else {
+              const helper = bindings.get(node.callee) ?? functions.get(node.callee);
+              if (helper)
+                found = hasAssertion(helper, bindings, seen);
+            }
+          });
+          return found;
+        }
+        for (const call of calls) {
+          const name = testTablesCallName(call.callee);
+          const argument = call.arguments[0];
+          if (tests.some((test) => name === test + ".extend") && argument && argument.type !== "SpreadElement") {
+            const fixtures = testTablesResolve(argument, values);
+            if (fixtures.type === "ObjectExpression") {
+              for (const property of fixtures.properties) {
+                if (property.type !== "Property")
+                  continue;
+                let value = property.value;
+                if (value.type === "ArrayExpression" && value.elements[0])
+                  value = value.elements[0];
+                const fn = functions.get(value) ?? value;
+                if (fn.type === "FunctionExpression" || fn.type === "ArrowFunctionExpression" || fn.type === "FunctionDeclaration")
+                  allowed.add(fn);
+              }
+            }
+          }
+          const registration = testTablesRegistration(call, tests, functions);
+          if (!registration)
+            continue;
+          allowed.add(registration.callback);
+          const builder = call.callee.type === "CallExpression" ? testTablesCallName(call.callee.callee) : undefined;
+          const parameter = registration.callback.params[builder?.endsWith(".for") ? 1 : 0];
+          if (!builder?.endsWith(".each") && parameter?.type === "ObjectPattern") {
+            const variables = context.sourceCode.getDeclaredVariables(registration.callback);
+            for (const property of parameter.properties) {
+              if (property.type !== "Property" || property.computed || property.key.type !== "Identifier" || property.key.name !== "expect" || property.value.type !== "Identifier")
+                continue;
+              const variable = variables.find((entry) => entry.identifiers.some((identifier) => identifier === property.value));
+              for (const reference of variable?.references ?? []) {
+                shadowed.delete(reference.identifier);
+                aliases.set(reference.identifier, "expect");
+              }
+            }
+          }
+          const rows = testTablesRows(registration, context.sourceCode, values, functions);
+          for (const row of rows ?? [])
+            for (const callback of row.callbacks)
+              allowed.add(callback);
+          const valid = rows ? rows.length > 0 && rows.every((row) => hasAssertion(registration.callback, row.bindings, new Set)) : hasAssertion(registration.callback, new Map, new Set);
+          if (!valid)
+            context.report({ node: call, messageId: "missing" });
+        }
+        for (const call of calls) {
+          const name = assertionName(call);
+          if (!name || !testAssertionFunctions.includes(name) || !name.startsWith("expect"))
+            continue;
+          let parent = call.parent;
+          let inside = false;
+          while (parent && parent.type !== "Program") {
+            if ((parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && allowed.has(parent)) {
+              inside = true;
+              break;
+            }
+            parent = parent.parent;
+          }
+          if (!inside)
+            context.report({ node: call, messageId: "standalone" });
+        }
+      }
+    };
+  }
+});
+
+// src/rules/module-policy/reasoned-directives.ts
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var directives = defineRule7({
   meta: {
     type: "problem",
     schema: [],
@@ -1281,8 +1590,8 @@ var directives = defineRule6({
 
 // src/rules/module-policy/tanstack-runtime.ts
 import { builtinModules } from "node:module";
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var tanstackRuntime = defineRule7({
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var tanstackRuntime = defineRule8({
   meta: {
     type: "problem",
     schema: [
@@ -1536,9 +1845,9 @@ var tanstackRuntime = defineRule7({
 });
 
 // src/rules/module-policy/import-boundaries.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
+import { defineRule as defineRule9 } from "@oxlint/plugins";
 import { resolve as resolve2, basename as basename2 } from "node:path";
-var importBoundaries = defineRule8({
+var importBoundaries = defineRule9({
   meta: {
     type: "problem",
     schema: [
@@ -1674,8 +1983,8 @@ var importBoundaries = defineRule8({
 });
 
 // src/rules/module-policy/memoization.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
-var memoization = defineRule9({
+import { defineRule as defineRule10 } from "@oxlint/plugins";
+var memoization = defineRule10({
   meta: {
     type: "problem",
     schema: [],
@@ -1718,6 +2027,7 @@ var memoization = defineRule9({
 var module_policy_default = eslintCompatPlugin({
   meta: { name: "modules" },
   rules: {
+    "test-assertions": testAssertions,
     "dynamic-classes": syntaxRule(':matches(JSXAttribute[name.name="className"] TemplateLiteral[expressions.length>0], JSXAttribute[name.name="className"] BinaryExpression[operator="+"])', "Write complete class names instead of constructing them dynamically."),
     "backend-switch": syntaxRule("SwitchStatement", "Use ts-pattern in backend application code."),
     "concurrent-db": syntaxRule('CallExpression[callee.object.name="test"][callee.property.name="concurrent"] ObjectPattern > Property[key.name="db"]', "Obtain an isolated database fixture for concurrent tests."),

package/dist/types/preset.types.d.ts

@@ -28,6 +28,7 @@ export interface PresetOptions {
     sql?: PresetSqlOptions;
     forms?: PresetFormsOptions;
     react?: PresetReactOptions;
+    tests?: PresetTestsOptions;
     policies?: PresetPolicyOptions;
     ignorePatterns?: string[];
     ruleExclusions?: Record<string, string[]>;
@@ -44,6 +45,12 @@ export interface PresetLimitsOptions {
 }
 export interface PresetModulesOptions {
     customFileRoles?: string[];
+    migrationFiles?: string[];
+}
+export interface PresetTestsOptions {
+    profile?: 'standard' | 'fixtures';
+    additionalTestFunctions?: string[];
+    additionalAssertionFunctions?: string[];
 }
 export interface PresetImportsOptions {
     backendEntryPoints?: string[];
@@ -63,6 +70,7 @@ export interface PresetFormsOptions {
 }
 export interface PresetReactOptions {
     compiler?: boolean;
+    componentProps?: boolean;
 }
 export interface PresetTanstackStartOptions {
     additionalServerOnlyImports?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-arch",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Configurable architecture rules for Oxlint JavaScript plugins.",
   "type": "module",
   "main": "./dist/index.js",