oxlint-plugin-effect 0.9.0 → 0.10.0

package/README.md

@@ -35,6 +35,7 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 | `effect/noNewPromise`              | Bans new Promise, Promise calls, and Promise static APIs                                  |
 | `effect/noNewError`                | Allows native Error values only as direct arguments to Effect.die, Cause.die, or Exit.die |
 | `effect/noNullish`                 | Bans null and undefined; use Option or a domain enum for richer state                     |
+| `effect/noModuleMocks`             | Bans Vitest and Jest module mocks and method spies; use Effect service test layers        |
 | `effect/noTernary`                 | Bans conditional expressions while allowing ordinary if statements                        |
 | `effect/noDynamicImports`          | Allows import() only behind a named lazy-loading boundary; bans require()                 |
 | `effect/noEffectDo`                | Bans Effect.Do                                                                            |

package/dist/presets/recommended.d.ts

@@ -14,6 +14,7 @@ declare const recommended: {
   readonly "effect/noEffectDo": "error";
   readonly "effect/noGlobals": "error";
   readonly "effect/noKnownValueWidening": "error";
+  readonly "effect/noModuleMocks": "error";
   readonly "effect/noNewError": "error";
   readonly "effect/noNewPromise": "error";
   readonly "effect/noNodeBuiltinImport": "error";

package/dist/presets/recommended.js

@@ -14,6 +14,7 @@ const recommended = {
 	"effect/noEffectDo": "error",
 	"effect/noGlobals": "error",
 	"effect/noKnownValueWidening": "error",
+	"effect/noModuleMocks": "error",
 	"effect/noNewError": "error",
 	"effect/noNewPromise": "error",
 	"effect/noNodeBuiltinImport": "error",

package/dist/rules/index.d.ts

@@ -7,6 +7,7 @@ import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-sp
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
+import { noModuleMocks } from "./no-module-mocks.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
@@ -29,7 +30,7 @@ import { preferPredicateIsTagged } from "./prefer-predicate-is-tagged.js";
 
 //#region src/rules/index.d.ts
 declare namespace index_d_exports {
-  export { noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noKnownValueWidening, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noRuntimeTypeof, noShapeInSymbolNames, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged };
+  export { noAs, noAsyncFunction, noChainedTypeAssertions, noConditionalEmptyObjectSpread, noDynamicImports, noEffectBind, noEffectDo, noGlobals, noKnownValueWidening, noModuleMocks, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noRuntimeTypeof, noShapeInSymbolNames, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged };
 }
 //#endregion
 export { index_d_exports };

package/dist/rules/index.js

@@ -8,6 +8,7 @@ import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-sp
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
+import { noModuleMocks } from "./no-module-mocks.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
@@ -38,6 +39,7 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	noEffectDo: () => noEffectDo,
 	noGlobals: () => noGlobals,
 	noKnownValueWidening: () => noKnownValueWidening,
+	noModuleMocks: () => noModuleMocks,
 	noNewError: () => noNewError,
 	noNewPromise: () => noNewPromise,
 	noNodeBuiltinImport: () => noNodeBuiltinImport,

package/dist/rules/no-module-mocks.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-module-mocks.d.ts
+declare const noModuleMocks: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noModuleMocks };

package/dist/rules/no-module-mocks.js

@@ -0,0 +1,73 @@
+import { importSource, memberNames, narrow } from "../vendor/effect-oxlint/AST.js";
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import { findVariableUp } from "../vendor/effect-oxlint/Scope.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-module-mocks.ts
+const bannedMethods = new Set(["mock", "spyOn"]);
+const identifierName = (node) => {
+	if (node?.type === "Identifier") return node.name;
+};
+const globalTestApi = (name) => {
+	if (name === "jest" || name === "vi") return name;
+};
+const importedTestApi = (source, imported) => {
+	if (source === "vitest" && imported === "vi") return "vi";
+	if (source === "@jest/globals" && imported === "jest") return "jest";
+};
+const testApiFromVariable = (variable, importedBindings) => {
+	if (variable.defs.some((definition) => definition.type === "ImportBinding")) return importedBindings.get(variable.name);
+};
+const noModuleMocks = define({
+	name: "no-module-mocks",
+	meta: meta({
+		type: "problem",
+		description: "Use Effect service test layers instead of module mocks or method spies."
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const importedBindings = /* @__PURE__ */ new Map();
+		return {
+			ImportDeclaration: (node) => Option.match(narrow(node, "ImportDeclaration"), {
+				onNone: () => Effect.void,
+				onSome: (declaration) => {
+					const source = importSource(declaration);
+					for (const specifier of declaration.specifiers) {
+						if (specifier.type !== "ImportSpecifier") continue;
+						const imported = identifierName(specifier.imported);
+						if (imported === void 0) continue;
+						const api = importedTestApi(source, imported);
+						if (api !== void 0) importedBindings.set(specifier.local.name, api);
+					}
+					return Effect.void;
+				}
+			}),
+			CallExpression: (node) => Option.match(narrow(node, "CallExpression"), {
+				onNone: () => Effect.void,
+				onSome: (call) => {
+					if (call.callee.type !== "MemberExpression") return Effect.void;
+					const names = Option.getOrUndefined(memberNames(call.callee));
+					if (names === void 0) return Effect.void;
+					const [object, method] = names;
+					if (!bannedMethods.has(method)) return Effect.void;
+					const variable = Option.getOrUndefined(findVariableUp(context.sourceCode.getScope(call), object));
+					let api = globalTestApi(object);
+					if (variable !== void 0) {
+						api = testApiFromVariable(variable, importedBindings);
+						if (api === void 0 && variable.defs.length === 0) api = globalTestApi(object);
+					}
+					if (api === void 0) return Effect.void;
+					return context.report(make({
+						node: call,
+						message: `Avoid ${api}.${method}(). Replace the external boundary with an Effect service test Layer.`
+					}));
+				}
+			})
+		};
+	}
+});
+//#endregion
+export { noModuleMocks };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",
   "repository": {