oxlint-plugin-effect 0.9.0 → 0.11.0

package/README.md

@@ -25,26 +25,38 @@ If the project uses JSON configuration, copy the exported rule map into `rules`;
 
 ## Recommended Rules
 
-| Rule                               | Contract                                                                                  |
-| ---------------------------------- | ----------------------------------------------------------------------------------------- |
-| `effect/noAs`                      | Bans TypeScript `as` assertions; use `satisfies`                                          |
-| `effect/noAsyncFunction`           | Bans async functions and await expressions                                                |
-| `effect/noTryCatch`                | Bans every try/catch/finally statement                                                    |
-| `effect/noTestLifecycleHooks`      | Bans `beforeEach`, `afterEach`, `beforeAll`, and `afterAll`; use Effect scopes instead    |
-| `effect/noThrowStatement`          | Bans every throw statement                                                                |
-| `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/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                                                                            |
-| `effect/noEffectBind`              | Bans Effect.bind                                                                          |
-| `effect/preferCatchTag`            | Replaces manual `_tag` predicates in `Effect.catchIf` with tagged recovery                |
-| `effect/preferEffectFn`            | Requires `Effect.fn` for a generator operation that adds a span                           |
-| `effect/preferMatchTagsExhaustive` | Requires exhaustive `Match` for return-only `_tag` switches                               |
-| `effect/preferPredicateIsTagged`   | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
-| `effect/noGlobals`                 | Bans ambient capabilities with direct Effect replacements; allows `process.std*.isTTY`    |
-| `effect/noNodeBuiltinImport`       | Bans fully replaced Node modules and replaced operations from partial modules             |
+| Rule                                   | Contract                                                                                  |
+| -------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `effect/noAs`                          | Bans TypeScript `as` assertions; use `satisfies`                                          |
+| `effect/noAsyncFunction`               | Bans async functions and await expressions                                                |
+| `effect/noTryCatch`                    | Bans every try/catch/finally statement                                                    |
+| `effect/noTestLifecycleHooks`          | Bans `beforeEach`, `afterEach`, `beforeAll`, and `afterAll`; use Effect scopes instead    |
+| `effect/noThrowStatement`              | Bans every throw statement                                                                |
+| `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/noManagedRuntimeInEffect`      | Keeps ManagedRuntime construction at non-Effect host boundaries                           |
+| `effect/noInlineProvide`               | Keeps dependency provisioning at explicit composition boundaries                          |
+| `effect/noNestedEffectGen`             | Flattens directly yielded nested generators                                               |
+| `effect/noPerCallCacheConstruction`    | Constructs shared caches once in their owning layer                                       |
+| `effect/noRunCollectOnUnboundedStream` | Requires termination before collecting a clearly unbounded Stream                         |
+| `effect/noSequentialEffectAll`         | Uses explicit sequencing when serial aggregation discards its result                      |
+| `effect/noSilentCatchAll`              | Keeps swallowed failures visible or recovers them truthfully                              |
+| `effect/noUnboundedConcurrency`        | Requires finite concurrency for collections that can grow                                 |
+| `effect/noUnboundedRetry`              | Requires an attempt or duration bound on retry schedules                                  |
+| `effect/noDynamicImports`              | Allows import() only behind a named lazy-loading boundary; bans require()                 |
+| `effect/noEffectDo`                    | Bans Effect.Do                                                                            |
+| `effect/noEffectBind`                  | Bans Effect.bind                                                                          |
+| `effect/preferCatchTag`                | Replaces manual `_tag` predicates and `catchAll` dispatch with tagged recovery            |
+| `effect/preferEffectFn`                | Requires `Effect.fn` for a generator operation that adds a span                           |
+| `effect/preferMatchTagsExhaustive`     | Requires exhaustive `Match` for return-only `_tag` switches and if chains                 |
+| `effect/preferPredicateIsTagged`       | Replaces combined `_tag` comparisons with a named `Predicate` refinement                  |
+| `effect/preferServiceOf`               | Checks inline Layer implementations through `Service.of`                                  |
+| `effect/requireNamedEffectFn`          | Requires stable names for `Effect.fn` operations                                          |
+| `effect/noGlobals`                     | Bans ambient capabilities with direct Effect replacements; allows `process.std*.isTTY`    |
+| `effect/noNodeBuiltinImport`           | Bans fully replaced Node modules and replaced operations from partial modules             |
 
 ## Anti-Slop Rules
 

package/dist/presets/recommended.d.ts

@@ -13,18 +13,28 @@ declare const recommended: {
   readonly "effect/noEffectBind": "error";
   readonly "effect/noEffectDo": "error";
   readonly "effect/noGlobals": "error";
+  readonly "effect/noInlineProvide": "error";
   readonly "effect/noKnownValueWidening": "error";
+  readonly "effect/noManagedRuntimeInEffect": "error";
+  readonly "effect/noModuleMocks": "error";
+  readonly "effect/noNestedEffectGen": "error";
   readonly "effect/noNewError": "error";
   readonly "effect/noNewPromise": "error";
   readonly "effect/noNodeBuiltinImport": "error";
   readonly "effect/noNullish": "error";
   readonly "effect/noObjectParameters": "error";
+  readonly "effect/noPerCallCacheConstruction": "error";
+  readonly "effect/noRunCollectOnUnboundedStream": "error";
   readonly "effect/noRuntimeTypeof": "error";
+  readonly "effect/noSequentialEffectAll": "error";
   readonly "effect/noShapeInSymbolNames": "error";
+  readonly "effect/noSilentCatchAll": "error";
   readonly "effect/noTernary": "error";
   readonly "effect/noTestLifecycleHooks": "error";
   readonly "effect/noThrowStatement": "error";
   readonly "effect/noTryCatch": "error";
+  readonly "effect/noUnboundedConcurrency": "error";
+  readonly "effect/noUnboundedRetry": "error";
   readonly "effect/noUnknownParameters": "error";
   readonly "effect/noUnknownTypeAliases": "error";
   readonly "effect/noUnsafeDictionaryType": "error";
@@ -33,6 +43,8 @@ declare const recommended: {
   readonly "effect/preferEffectFn": "error";
   readonly "effect/preferMatchTagsExhaustive": "error";
   readonly "effect/preferPredicateIsTagged": "error";
+  readonly "effect/preferServiceOf": "error";
+  readonly "effect/requireNamedEffectFn": "error";
 };
 //#endregion
 export { recommended };

package/dist/presets/recommended.js

@@ -13,18 +13,28 @@ const recommended = {
 	"effect/noEffectBind": "error",
 	"effect/noEffectDo": "error",
 	"effect/noGlobals": "error",
+	"effect/noInlineProvide": "error",
 	"effect/noKnownValueWidening": "error",
+	"effect/noManagedRuntimeInEffect": "error",
+	"effect/noModuleMocks": "error",
+	"effect/noNestedEffectGen": "error",
 	"effect/noNewError": "error",
 	"effect/noNewPromise": "error",
 	"effect/noNodeBuiltinImport": "error",
 	"effect/noNullish": "error",
 	"effect/noObjectParameters": "error",
+	"effect/noPerCallCacheConstruction": "error",
+	"effect/noRunCollectOnUnboundedStream": "error",
 	"effect/noRuntimeTypeof": "error",
+	"effect/noSequentialEffectAll": "error",
 	"effect/noShapeInSymbolNames": "error",
+	"effect/noSilentCatchAll": "error",
 	"effect/noTernary": "error",
 	"effect/noTestLifecycleHooks": "error",
 	"effect/noThrowStatement": "error",
 	"effect/noTryCatch": "error",
+	"effect/noUnboundedConcurrency": "error",
+	"effect/noUnboundedRetry": "error",
 	"effect/noUnknownParameters": "error",
 	"effect/noUnknownTypeAliases": "error",
 	"effect/noUnsafeDictionaryType": "error",
@@ -32,7 +42,9 @@ const recommended = {
 	"effect/preferCatchTag": "error",
 	"effect/preferEffectFn": "error",
 	"effect/preferMatchTagsExhaustive": "error",
-	"effect/preferPredicateIsTagged": "error"
+	"effect/preferPredicateIsTagged": "error",
+	"effect/preferServiceOf": "error",
+	"effect/requireNamedEffectFn": "error"
 };
 //#endregion
 export { recommended };

package/dist/rules/_effect-context.js

@@ -0,0 +1,27 @@
+import { isStaticCall, isStaticMember } from "./_effect-namespaces.js";
+//#region src/rules/_effect-context.ts
+const isFunction = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+const effectProgramKind = (node, effectNamespaces) => {
+	const parent = node.parent;
+	if (parent?.type !== "CallExpression" || !parent.arguments.includes(node)) return void 0;
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "gen")) return "gen";
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fn")) return "fn";
+	if (parent.callee.type !== "Super" && isStaticMember(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
+	if (parent.callee.type !== "CallExpression") return void 0;
+	if (isStaticCall(parent.callee, effectNamespaces, "fn")) return "fn";
+	if (isStaticCall(parent.callee, effectNamespaces, "fnUntraced")) return "fnUntraced";
+};
+const enclosingEffectProgram = (node, effectNamespaces) => {
+	let current = node.parent;
+	while (current !== void 0 && current !== null) {
+		if (isFunction(current)) {
+			const kind = effectProgramKind(current, effectNamespaces);
+			if (kind === void 0) return void 0;
+			return [current, kind];
+		}
+		current = current.parent;
+	}
+};
+const isInsideEffectProgram = (node, effectNamespaces) => enclosingEffectProgram(node, effectNamespaces) !== void 0;
+//#endregion
+export { enclosingEffectProgram, isInsideEffectProgram };

package/dist/rules/_effect-namespaces.js

@@ -0,0 +1,25 @@
+import { findVariableUp } from "../vendor/effect-oxlint/Scope.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
+//#region src/rules/_effect-namespaces.ts
+const importedNamespaces = (node, exportName, directModule) => {
+	const source = node.source.value;
+	if (source !== "effect" && source !== directModule) return [];
+	const namespaces = [];
+	for (const specifier of node.specifiers) {
+		if (specifier.type === "ImportNamespaceSpecifier" && source === directModule) {
+			namespaces.push(specifier.local.name);
+			continue;
+		}
+		if (specifier.type === "ImportSpecifier" && source === "effect" && specifier.imported.type === "Identifier" && specifier.imported.name === exportName) namespaces.push(specifier.local.name);
+	}
+	return namespaces;
+};
+const visibleNamespaces = (ctx, node, namespaces) => new Set([...namespaces].filter((namespace) => Option.match(findVariableUp(ctx.sourceCode.getScope(node), namespace), {
+	onNone: () => true,
+	onSome: (variable) => variable.defs.some((definition) => definition.type === "ImportBinding")
+})));
+const isStaticMember = (node, namespaces, property) => node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && namespaces.has(node.object.name) && node.property.type === "Identifier" && node.property.name === property;
+const isStaticCall = (node, namespaces, property) => node.type === "CallExpression" && node.callee.type !== "Super" && isStaticMember(node.callee, namespaces, property);
+//#endregion
+export { importedNamespaces, isStaticCall, isStaticMember, visibleNamespaces };

package/dist/rules/_tagged-control-flow.js

@@ -76,4 +76,4 @@ const isInsideCatchAllHandler = (node) => {
 };
 const taggedSwitchSubject = (node) => taggedSubject(node.discriminant);
 //#endregion
-export { effectCallbackLocation, hasOneTaggedSubject, isEffectCall, isInsideCatchAllHandler, tagComparisonsInOr, taggedSwitchSubject };
+export { effectCallbackLocation, hasOneTaggedSubject, isEffectCall, isInsideCatchAllHandler, tagComparison, tagComparisonsInOr, taggedSwitchSubject };

package/dist/rules/index.d.ts

@@ -6,18 +6,28 @@ import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
 import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
+import { noInlineProvide } from "./no-inline-provide.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
+import { noManagedRuntimeInEffect } from "./no-managed-runtime-in-effect.js";
+import { noModuleMocks } from "./no-module-mocks.js";
+import { noNestedEffectGen } from "./no-nested-effect-gen.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
 import { noObjectParameters } from "./no-object-parameters.js";
+import { noPerCallCacheConstruction } from "./no-per-call-cache-construction.js";
+import { noRunCollectOnUnboundedStream } from "./no-run-collect-on-unbounded-stream.js";
 import { noRuntimeTypeof } from "./no-runtime-typeof.js";
+import { noSequentialEffectAll } from "./no-sequential-effect-all.js";
 import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
+import { noSilentCatchAll } from "./no-silent-catch-all.js";
 import { noTernary } from "./no-ternary.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
+import { noUnboundedConcurrency } from "./no-unbounded-concurrency.js";
+import { noUnboundedRetry } from "./no-unbounded-retry.js";
 import { noUnknownParameters } from "./no-unknown-parameters.js";
 import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
 import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
@@ -26,10 +36,12 @@ import { preferCatchTag } from "./prefer-catch-tag.js";
 import { preferEffectFn } from "./prefer-effect-fn.js";
 import { preferMatchTagsExhaustive } from "./prefer-match-tags-exhaustive.js";
 import { preferPredicateIsTagged } from "./prefer-predicate-is-tagged.js";
+import { preferServiceOf } from "./prefer-service-of.js";
+import { requireNamedEffectFn } from "./require-named-effect-fn.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, noInlineProvide, noKnownValueWidening, noManagedRuntimeInEffect, noModuleMocks, noNestedEffectGen, noNewError, noNewPromise, noNodeBuiltinImport, noNullish, noObjectParameters, noPerCallCacheConstruction, noRunCollectOnUnboundedStream, noRuntimeTypeof, noSequentialEffectAll, noShapeInSymbolNames, noSilentCatchAll, noTernary, noTestLifecycleHooks, noThrowStatement, noTryCatch, noUnboundedConcurrency, noUnboundedRetry, noUnknownParameters, noUnknownTypeAliases, noUnsafeDictionaryType, noWidenThenAssert, preferCatchTag, preferEffectFn, preferMatchTagsExhaustive, preferPredicateIsTagged, preferServiceOf, requireNamedEffectFn };
 }
 //#endregion
 export { index_d_exports };

package/dist/rules/index.js

@@ -7,18 +7,28 @@ import { noChainedTypeAssertions } from "./no-chained-type-assertions.js";
 import { noConditionalEmptyObjectSpread } from "./no-conditional-empty-object-spread.js";
 import { noDynamicImports } from "./no-dynamic-imports.js";
 import { noGlobals } from "./no-globals.js";
+import { noInlineProvide } from "./no-inline-provide.js";
 import { noKnownValueWidening } from "./no-known-value-widening.js";
+import { noManagedRuntimeInEffect } from "./no-managed-runtime-in-effect.js";
+import { noModuleMocks } from "./no-module-mocks.js";
+import { noNestedEffectGen } from "./no-nested-effect-gen.js";
 import { noNewError } from "./no-new-error.js";
 import { noNewPromise } from "./no-new-promise.js";
 import { noNodeBuiltinImport } from "./no-node-builtin-import.js";
 import { noNullish } from "./no-nullish.js";
 import { noObjectParameters } from "./no-object-parameters.js";
+import { noPerCallCacheConstruction } from "./no-per-call-cache-construction.js";
+import { noRunCollectOnUnboundedStream } from "./no-run-collect-on-unbounded-stream.js";
 import { noRuntimeTypeof } from "./no-runtime-typeof.js";
+import { noSequentialEffectAll } from "./no-sequential-effect-all.js";
 import { noShapeInSymbolNames } from "./no-shape-in-symbol-names.js";
+import { noSilentCatchAll } from "./no-silent-catch-all.js";
 import { noTernary } from "./no-ternary.js";
 import { noTestLifecycleHooks } from "./no-test-lifecycle-hooks.js";
 import { noThrowStatement } from "./no-throw-statement.js";
 import { noTryCatch } from "./no-try-catch.js";
+import { noUnboundedConcurrency } from "./no-unbounded-concurrency.js";
+import { noUnboundedRetry } from "./no-unbounded-retry.js";
 import { noUnknownParameters } from "./no-unknown-parameters.js";
 import { noUnknownTypeAliases } from "./no-unknown-type-aliases.js";
 import { noUnsafeDictionaryType } from "./no-unsafe-dictionary-type.js";
@@ -27,6 +37,8 @@ import { preferCatchTag } from "./prefer-catch-tag.js";
 import { preferEffectFn } from "./prefer-effect-fn.js";
 import { preferMatchTagsExhaustive } from "./prefer-match-tags-exhaustive.js";
 import { preferPredicateIsTagged } from "./prefer-predicate-is-tagged.js";
+import { preferServiceOf } from "./prefer-service-of.js";
+import { requireNamedEffectFn } from "./require-named-effect-fn.js";
 //#region src/rules/index.ts
 var rules_exports = /* @__PURE__ */ __exportAll({
 	noAs: () => noAs,
@@ -37,18 +49,28 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	noEffectBind: () => noEffectBind,
 	noEffectDo: () => noEffectDo,
 	noGlobals: () => noGlobals,
+	noInlineProvide: () => noInlineProvide,
 	noKnownValueWidening: () => noKnownValueWidening,
+	noManagedRuntimeInEffect: () => noManagedRuntimeInEffect,
+	noModuleMocks: () => noModuleMocks,
+	noNestedEffectGen: () => noNestedEffectGen,
 	noNewError: () => noNewError,
 	noNewPromise: () => noNewPromise,
 	noNodeBuiltinImport: () => noNodeBuiltinImport,
 	noNullish: () => noNullish,
 	noObjectParameters: () => noObjectParameters,
+	noPerCallCacheConstruction: () => noPerCallCacheConstruction,
+	noRunCollectOnUnboundedStream: () => noRunCollectOnUnboundedStream,
 	noRuntimeTypeof: () => noRuntimeTypeof,
+	noSequentialEffectAll: () => noSequentialEffectAll,
 	noShapeInSymbolNames: () => noShapeInSymbolNames,
+	noSilentCatchAll: () => noSilentCatchAll,
 	noTernary: () => noTernary,
 	noTestLifecycleHooks: () => noTestLifecycleHooks,
 	noThrowStatement: () => noThrowStatement,
 	noTryCatch: () => noTryCatch,
+	noUnboundedConcurrency: () => noUnboundedConcurrency,
+	noUnboundedRetry: () => noUnboundedRetry,
 	noUnknownParameters: () => noUnknownParameters,
 	noUnknownTypeAliases: () => noUnknownTypeAliases,
 	noUnsafeDictionaryType: () => noUnsafeDictionaryType,
@@ -56,7 +78,9 @@ var rules_exports = /* @__PURE__ */ __exportAll({
 	preferCatchTag: () => preferCatchTag,
 	preferEffectFn: () => preferEffectFn,
 	preferMatchTagsExhaustive: () => preferMatchTagsExhaustive,
-	preferPredicateIsTagged: () => preferPredicateIsTagged
+	preferPredicateIsTagged: () => preferPredicateIsTagged,
+	preferServiceOf: () => preferServiceOf,
+	requireNamedEffectFn: () => requireNamedEffectFn
 });
 //#endregion
 export { rules_exports };

package/dist/rules/no-inline-provide.d.ts

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

package/dist/rules/no-inline-provide.js

@@ -0,0 +1,39 @@
+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 "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { isInsideEffectProgram } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-inline-provide.ts
+/** Keep Effect provisioning at explicit composition boundaries. */
+const noInlineProvide = define({
+	name: "no-inline-provide",
+	meta: meta({
+		type: "problem",
+		description: "Keep Effect provisioning outside domain Effect operations."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!isStaticMember(node.callee, namespaces, "provide")) return Effect.void;
+				if (!isInsideEffectProgram(node, namespaces)) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Do not provide dependencies inside an Effect operation. Provide the layer once at the application, handler, command, or test boundary."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noInlineProvide };

package/dist/rules/no-managed-runtime-in-effect.d.ts

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

package/dist/rules/no-managed-runtime-in-effect.js

@@ -0,0 +1,41 @@
+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 "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { isInsideEffectProgram } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-managed-runtime-in-effect.ts
+/** Keep ManagedRuntime construction at non-Effect host boundaries. */
+const noManagedRuntimeInEffect = define({
+	name: "no-managed-runtime-in-effect",
+	meta: meta({
+		type: "problem",
+		description: "Create ManagedRuntime only at a non-Effect host boundary."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		const managedRuntimeNamespaces = new Set(["ManagedRuntime"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				for (const name of importedNamespaces(node, "ManagedRuntime", "effect/ManagedRuntime")) managedRuntimeNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const runtimes = visibleNamespaces(ctx, node, managedRuntimeNamespaces);
+				if (!isStaticMember(node.callee, runtimes, "make")) return Effect.void;
+				if (!isInsideEffectProgram(node, visibleNamespaces(ctx, node, effectNamespaces))) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Create ManagedRuntime only at a non-Effect host boundary. Use the current Effect environment inside Effect programs."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noManagedRuntimeInEffect };

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/dist/rules/no-nested-effect-gen.d.ts

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

package/dist/rules/no-nested-effect-gen.js

@@ -0,0 +1,39 @@
+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 "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { isInsideEffectProgram } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-nested-effect-gen.ts
+const isDirectYield = (node) => node.parent?.type === "YieldExpression";
+const noNestedEffectGen = define({
+	name: "no-nested-effect-gen",
+	meta: meta({
+		type: "suggestion",
+		description: "Flatten directly yielded nested Effect.gen programs."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const namespaces = visibleNamespaces(ctx, node, effectNamespaces);
+				if (!isStaticMember(node.callee, namespaces, "gen") || !isDirectYield(node)) return Effect.void;
+				if (!isInsideEffectProgram(node, namespaces)) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Flatten this directly yielded Effect.gen into the owning Effect operation."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noNestedEffectGen };

package/dist/rules/no-per-call-cache-construction.d.ts

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

package/dist/rules/no-per-call-cache-construction.js

@@ -0,0 +1,52 @@
+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 "../vendor/effect-oxlint/index.js";
+import { importedNamespaces, isStaticMember, visibleNamespaces } from "./_effect-namespaces.js";
+import { enclosingEffectProgram } from "./_effect-context.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-per-call-cache-construction.ts
+const cachedEffectOperations = new Set([
+	"cached",
+	"cachedInvalidateWithTTL",
+	"cachedWithTTL"
+]);
+const cacheConstructors = new Set(["make", "makeWith"]);
+const isOperation = (node, namespaces, operations) => {
+	for (const operation of operations) if (isStaticMember(node, namespaces, operation)) return true;
+	return false;
+};
+const noPerCallCacheConstruction = define({
+	name: "no-per-call-cache-construction",
+	meta: meta({
+		type: "suggestion",
+		description: "Construct shared caches once in their owning layer."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const effectNamespaces = new Set(["Effect"]);
+		const cacheNamespaces = new Set(["Cache"]);
+		return {
+			ImportDeclaration: (node) => {
+				if (node.type !== "ImportDeclaration") return Effect.void;
+				for (const name of importedNamespaces(node, "Effect", "effect/Effect")) effectNamespaces.add(name);
+				for (const name of importedNamespaces(node, "Cache", "effect/Cache")) cacheNamespaces.add(name);
+				return Effect.void;
+			},
+			CallExpression: (node) => {
+				if (node.type !== "CallExpression" || node.callee.type === "Super") return Effect.void;
+				const effects = visibleNamespaces(ctx, node, effectNamespaces);
+				const program = enclosingEffectProgram(node, effects);
+				if (program === void 0 || program[1] === "gen") return Effect.void;
+				const caches = visibleNamespaces(ctx, node, cacheNamespaces);
+				if (!(isOperation(node.callee, effects, cachedEffectOperations) || isOperation(node.callee, caches, cacheConstructors))) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Construct this cache once in its owning layer. Creating it inside an Effect operation creates new cache state on every call."
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noPerCallCacheConstruction };

package/dist/rules/no-run-collect-on-unbounded-stream.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-run-collect-on-unbounded-stream.d.ts
+declare const noRunCollectOnUnboundedStream: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noRunCollectOnUnboundedStream };