oxlint-plugin-effect 0.0.0

package/src/rules/no-fromnullable-coalesce.ts

@@ -0,0 +1,63 @@
+/**
+ * Ban `Option.fromNullable(x ?? null)` / `Option.fromNullable(x ?? undefined)`.
+ *
+ * The nullish coalescing is redundant — pass the source directly.
+ *
+ * Source: biome-effect-linting-rules/no-fromnullable-nullish-coalesce
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+export const noFromNullableCoalesce = Rule.define({
+  name: "no-fromnullable-coalesce",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Redundant nullish coalescing in Option.fromNullable. Pass the value directly.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        // Match Option.fromNullable(...) or Option.fromNullishOr(...)
+        const ce = node as ESTree.CallExpression
+        const isFromNullable =
+          AST.isCallOf(ce, "Option", "fromNullable") ||
+          AST.isCallOf(ce, "Option", "fromNullishOr")
+        if (!isFromNullable) return Effect.void
+
+        if ("arguments" in node && Array.isArray(node.arguments) && node.arguments.length >= 1) {
+          const arg = node.arguments[0]
+          if (
+            arg != null &&
+            typeof arg === "object" &&
+            "type" in arg &&
+            arg.type === "LogicalExpression" &&
+            "operator" in arg &&
+            arg.operator === "??"
+          ) {
+            // Check RHS is null or undefined
+            if ("right" in arg && arg.right != null && typeof arg.right === "object" && "type" in arg.right) {
+              const rhs = arg.right
+              const isNullish =
+                (rhs.type === "Literal" && "value" in rhs && rhs.value === null) ||
+                (rhs.type === "Identifier" && "name" in rhs && rhs.name === "undefined")
+              if (isNullish) {
+                return ctx.report(
+                  Diagnostic.make({
+                    node,
+                    message:
+                      "Redundant ?? null/undefined in Option.fromNullable. Pass the value directly.",
+                  }),
+                )
+              }
+            }
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-global-console.ts

@@ -0,0 +1,17 @@
+/**
+ * Ban `console.log/warn/error/info/debug/trace`.
+ *
+ * Use Effect Logger service instead.
+ *
+ * Source: language-service/globalConsole
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noGlobalConsole = Rule.banMember(
+  "console",
+  ["log", "warn", "error", "info", "debug", "trace"],
+  {
+    message: "Avoid console.*. Use Effect Logger service.",
+    meta: { type: "suggestion" },
+  },
+)

package/src/rules/no-global-date.ts

@@ -0,0 +1,20 @@
+/**
+ * Ban `Date.now()` and `new Date()`.
+ *
+ * Use Effect Clock service instead.
+ *
+ * Source: language-service/globalDate
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noGlobalDate = Rule.banMultiple(
+  {
+    newExprs: "Date",
+    members: [["Date", "now"]],
+  },
+  {
+    name: "no-global-date",
+    message: "Avoid Date.now() and new Date(). Use Clock service.",
+    meta: { type: "suggestion" },
+  },
+)

package/src/rules/no-global-fetch.ts

@@ -0,0 +1,14 @@
+/**
+ * Ban bare `fetch()` calls.
+ *
+ * Use Effect HttpClient service instead.
+ *
+ * Source: language-service/globalFetch
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noGlobalFetch = Rule.banCallOf("fetch", {
+  message:
+    "Avoid global fetch. Use HttpClient from 'effect/unstable/http'.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-global-random.ts

@@ -0,0 +1,13 @@
+/**
+ * Ban `Math.random()`.
+ *
+ * Use Effect Random service instead.
+ *
+ * Source: language-service/globalRandom
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noGlobalRandom = Rule.banMember("Math", "random", {
+  message: "Avoid Math.random(). Use Random service.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-global-timers.ts

@@ -0,0 +1,17 @@
+/**
+ * Ban `setTimeout` and `setInterval`.
+ *
+ * Use Effect Schedule or Effect.sleep instead.
+ *
+ * Source: language-service/globalTimers
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noGlobalTimers = Rule.banCallOf(
+  ["setTimeout", "setInterval"],
+  {
+    message:
+      "Avoid setTimeout/setInterval. Use Effect.sleep or Schedule.",
+    meta: { type: "suggestion" },
+  },
+)

package/src/rules/no-if-statement.ts

@@ -0,0 +1,16 @@
+/**
+ * Ban `if` statements in Effect codebases.
+ *
+ * Use `Option.match`, `Either.match`, `Match.value`, or data combinators.
+ *
+ * Source: biome-effect-linting-rules/no-if-statement
+ *
+ * Note: Very opinionated — recommended for strict functional presets only.
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noIfStatement = Rule.banStatement("IfStatement", {
+  message:
+    "Avoid if statements. Use Option.match, Either.match, Match.value, or Effect.if.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-iife-wrapper.ts

@@ -0,0 +1,52 @@
+/**
+ * Ban immediately-invoked function expressions (IIFEs).
+ *
+ * Use named const binding + flat pipeline.
+ *
+ * Source: biome-effect-linting-rules/no-iife-wrapper
+ */
+import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+export const noIifeWrapper = Rule.define({
+  name: "no-iife-wrapper",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid IIFEs. Use named const bindings + flat pipeline.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!("callee" in node)) return Effect.void
+        const callee = node.callee
+        if (callee == null || typeof callee !== "object" || !("type" in callee)) return Effect.void
+
+        const isWrappedFn =
+          callee.type === "ArrowFunctionExpression" ||
+          callee.type === "FunctionExpression"
+
+        // Also catch (expr)(...) where expr is parenthesized fn
+        const isParenWrapped =
+          callee.type === "ParenthesizedExpression" &&
+          "expression" in callee &&
+          callee.expression != null &&
+          typeof callee.expression === "object" &&
+          "type" in callee.expression &&
+          (callee.expression.type === "ArrowFunctionExpression" ||
+            callee.expression.type === "FunctionExpression")
+
+        if (isWrappedFn || isParenWrapped) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message: "Avoid IIFEs. Use named const binding + flat pipeline.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-inline-runtime-provide.ts

@@ -0,0 +1,42 @@
+/**
+ * Ban `Effect.provide(layer)` used inline inside Effect.gen/fn.
+ *
+ * Provide layers at the boundary, not deep in generators.
+ *
+ * Source: biome-effect-linting-rules/no-inline-runtime-provide
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { AST, Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Ref from "effect/Ref"
+
+import { makeEffectContextTracker } from "./_effect-context.js"
+
+export const noInlineRuntimeProvide = Rule.define({
+  name: "no-inline-runtime-provide",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Effect.provide inside Effect.gen/fn. Provide layers at the boundary.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      CallExpression: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) => {
+          if (d <= 0) return Effect.void
+          if (!AST.isCallOf(node as ESTree.CallExpression, "Effect", "provide")) return Effect.void
+
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message: "Avoid Effect.provide inside Effect.gen/fn. Provide layers at the boundary.",
+            }),
+          )
+        }),
+    })
+  },
+})

package/src/rules/no-instanceof-schema.ts

@@ -0,0 +1,43 @@
+/**
+ * Ban `instanceof` checks against Schema-derived classes.
+ *
+ * Use `Schema.is(SchemaType)` instead.
+ *
+ * Source: language-service/instanceOfSchema
+ *
+ * Note: Without type information, we detect common Effect Schema class names
+ * used in `instanceof` checks. This is a best-effort heuristic.
+ */
+import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+export const noInstanceofSchema = Rule.define({
+  name: "no-instanceof-schema",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid instanceof with Schema types. Use Schema.is(SchemaType) instead.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      BinaryExpression: (node) => {
+        if (
+          "operator" in node &&
+          node.operator === "instanceof"
+        ) {
+          // Report all instanceof — in Effect codebases, instanceof is generally wrong
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Avoid instanceof. Use Schema.is(SchemaType) for Schema types, or _tag checks for tagged types.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-json-in-effect.ts

@@ -0,0 +1,45 @@
+/**
+ * Ban `JSON.parse`/`JSON.stringify` inside Effect.gen/fn context.
+ *
+ * Use Schema.fromJsonString for type-safe JSON.
+ *
+ * Source: language-service/preferSchemaOverJson (inside Effect context)
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { AST, Diagnostic, Rule, Visitor } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Ref from "effect/Ref"
+
+import { makeEffectContextTracker } from "./_effect-context.js"
+
+export const noJsonInEffect = Rule.define({
+  name: "no-json-in-effect",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid JSON.parse/stringify inside Effect.gen/fn. Use Schema.fromJsonString.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const [depth, tracker] = yield* makeEffectContextTracker
+
+    return Visitor.merge(tracker, {
+      MemberExpression: (node) =>
+        Effect.flatMap(Ref.get(depth), (d) => {
+          if (
+            d > 0 &&
+            Option.isSome(AST.matchMember(node as ESTree.MemberExpression, "JSON", ["parse", "stringify"]))
+          ) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message: "Avoid JSON.parse/stringify inside Effect context. Use Schema.fromJsonString.",
+              }),
+            )
+          }
+          return Effect.void
+        }),
+    })
+  },
+})

package/src/rules/no-json-parse.ts

@@ -0,0 +1,18 @@
+/**
+ * Ban `JSON.parse` and `JSON.stringify`.
+ *
+ * Use Schema.fromJsonString for type-safe JSON handling.
+ *
+ * Source: language-service/preferSchemaOverJson
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noJsonParse = Rule.banMember(
+  "JSON",
+  ["parse", "stringify"],
+  {
+    message:
+      "Avoid JSON.parse/stringify. Use Schema.fromJsonString for type-safe JSON.",
+    meta: { type: "suggestion" },
+  },
+)

package/src/rules/no-manual-effect-channels.ts

@@ -0,0 +1,59 @@
+/**
+ * Ban manual `Effect.Effect<A, E, R>` type annotations.
+ *
+ * Let return types infer from the Effect/Layer you return.
+ *
+ * Source: biome-effect-linting-rules/no-manual-effect-channels
+ */
+import { Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+export const noManualEffectChannels = Rule.define({
+  name: "no-manual-effect-channels",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid manual Effect.Effect<A, E, R> annotations. Let types infer from the returned Effect.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      TSTypeReference: (node) => {
+        if (!("typeName" in node) || node.typeName == null) return Effect.void
+        const typeName = node.typeName as unknown as Record<string, unknown>
+
+        // Effect.Effect<...> or Layer.Layer<...>
+        if (typeName["type"] === "TSQualifiedName" && "left" in typeName && "right" in typeName) {
+          const left = typeName["left"] as unknown as Record<string, unknown> | null
+          const right = typeName["right"] as unknown as Record<string, unknown> | null
+          if (
+            left != null && left["type"] === "Identifier" &&
+            (left["name"] === "Effect" || left["name"] === "Layer") &&
+            right != null && right["type"] === "Identifier" &&
+            (right["name"] === "Effect" || right["name"] === "Layer")
+          ) {
+            // Only flag if explicit type parameters are provided
+            if (
+              "typeParameters" in node &&
+              node.typeParameters != null &&
+              typeof node.typeParameters === "object" &&
+              "params" in (node.typeParameters as unknown as Record<string, unknown>) &&
+              Array.isArray((node.typeParameters as unknown as Record<string, unknown>)["params"]) &&
+              ((node.typeParameters as unknown as Record<string, unknown>)["params"] as unknown[]).length > 0
+            ) {
+              return ctx.report(
+                Diagnostic.make({
+                  node,
+                  message:
+                    "Avoid manual Effect/Layer channel annotations. Let types infer from the returned value.",
+                }),
+              )
+            }
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-match-effect-branch.ts

@@ -0,0 +1,83 @@
+/**
+ * Ban Match.when/orElse branches that contain multi-step Effect sequencing.
+ *
+ * Select the value in Match, then run one Effect pipeline outside.
+ *
+ * Source: biome-effect-linting-rules/no-match-effect-branch
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+const sequencingMethods = new Set(["flatMap", "map", "andThen", "tap", "zipRight", "pipe"])
+
+const containsEffectSequencing = (node: unknown): boolean => {
+  if (node == null || typeof node !== "object") return false
+  const n = node as Record<string, unknown>
+  if (n["type"] === "CallExpression" && "callee" in n) {
+    const callee = n["callee"] as Record<string, unknown> | null
+    if (callee != null && callee["type"] === "MemberExpression") {
+      const obj = callee["object"] as Record<string, unknown> | null
+      const prop = callee["property"] as Record<string, unknown> | null
+      if (
+        obj != null && obj["type"] === "Identifier" && obj["name"] === "Effect" &&
+        prop != null && prop["type"] === "Identifier" && typeof prop["name"] === "string" &&
+        sequencingMethods.has(prop["name"])
+      ) {
+        return true
+      }
+    }
+    if ("arguments" in n && Array.isArray(n["arguments"])) {
+      for (const arg of n["arguments"]) {
+        if (containsEffectSequencing(arg)) return true
+      }
+    }
+  }
+  if ("body" in n) {
+    if (Array.isArray(n["body"])) {
+      for (const child of n["body"]) {
+        if (containsEffectSequencing(child)) return true
+      }
+    } else if (containsEffectSequencing(n["body"])) return true
+  }
+  if ("argument" in n && containsEffectSequencing(n["argument"])) return true
+  if ("expression" in n && containsEffectSequencing(n["expression"])) return true
+  return false
+}
+
+export const noMatchEffectBranch = Rule.define({
+  name: "no-match-effect-branch",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Effect sequencing inside Match branches. Select value in Match, run Effect outside.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        const ce = node as ESTree.CallExpression
+        const isMatchWhen = AST.isCallOf(ce, "Match", "when")
+        const isMatchOrElse = AST.isCallOf(ce, "Match", "orElse")
+
+        if (!isMatchWhen && !isMatchOrElse) return Effect.void
+        if (!("arguments" in node) || !Array.isArray(node.arguments)) return Effect.void
+
+        // Check the callback argument for Effect sequencing
+        const callbackIdx = isMatchWhen ? 1 : 0
+        const callback = node.arguments[callbackIdx]
+        if (callback != null && containsEffectSequencing(callback)) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Avoid Effect sequencing inside Match branches. Select value in Match, then run one Effect pipeline outside.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-match-void-branch.ts

@@ -0,0 +1,73 @@
+/**
+ * Ban `Match.when(true/false, () => Effect.void)` and `Match.orElse(() => Effect.void)`.
+ *
+ * Remove the no-op branch or restructure.
+ *
+ * Source: biome-effect-linting-rules/no-match-void-branch
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+
+const isEffectVoid = (node: unknown): boolean => {
+  if (node == null || typeof node !== "object") return false
+  const n = node as Record<string, unknown>
+  if (n["type"] !== "MemberExpression") return false
+  const obj = n["object"] as Record<string, unknown> | null
+  const prop = n["property"] as Record<string, unknown> | null
+  return (
+    obj != null && obj["type"] === "Identifier" && obj["name"] === "Effect" &&
+    prop != null && prop["type"] === "Identifier" && prop["name"] === "void"
+  )
+}
+
+const isVoidCallback = (node: unknown): boolean => {
+  if (node == null || typeof node !== "object") return false
+  const n = node as Record<string, unknown>
+  if (n["type"] !== "ArrowFunctionExpression" && n["type"] !== "FunctionExpression") return false
+  if (!("body" in n)) return false
+  return isEffectVoid(n["body"])
+}
+
+export const noMatchVoidBranch = Rule.define({
+  name: "no-match-void-branch",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid no-op Match branches returning Effect.void. Remove the branch or restructure.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        const ce = node as ESTree.CallExpression
+        const isMatchWhen = AST.isCallOf(ce, "Match", "when")
+        const isMatchOrElse = AST.isCallOf(ce, "Match", "orElse")
+
+        if (!isMatchWhen && !isMatchOrElse) return Effect.void
+
+        if (!("arguments" in node) || !Array.isArray(node.arguments)) return Effect.void
+
+        if (isMatchOrElse && node.arguments.length >= 1 && isVoidCallback(node.arguments[0])) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message: "Match.orElse returning Effect.void is a no-op. Remove the branch or restructure.",
+            }),
+          )
+        }
+
+        if (isMatchWhen && node.arguments.length >= 2 && isVoidCallback(node.arguments[1])) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message: "Match.when branch returning Effect.void is a no-op. Remove the branch or restructure.",
+            }),
+          )
+        }
+
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-nested-effect-call.ts

@@ -0,0 +1,59 @@
+/**
+ * Ban nested Effect.* calls — `Effect.outer(Effect.inner(...))`.
+ *
+ * Build values first, then one flat pipeline.
+ *
+ * Sources: biome-effect-linting-rules/no-nested-effect-call, no-effect-call-in-effect-arg, no-call-tower, no-effect-ladder
+ */
+import type { ESTree } from "@oxlint/plugins"
+import { AST, Diagnostic, Rule } from "../vendor/effect-oxlint/index.js"
+import { RuleContext } from "../vendor/effect-oxlint/index.js"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+
+const isEffectCall = (node: unknown): boolean => {
+  if (node == null || typeof node !== "object") return false
+  const n = node as Record<string, unknown>
+  if (n["type"] !== "CallExpression") return false
+  const callee = n["callee"]
+  if (callee == null || typeof callee !== "object") return false
+  const c = callee as Record<string, unknown>
+  if (c["type"] !== "MemberExpression") return false
+  const obj = c["object"]
+  if (obj == null || typeof obj !== "object") return false
+  const o = obj as Record<string, unknown>
+  return o["type"] === "Identifier" && o["name"] === "Effect"
+}
+
+export const noNestedEffectCall = Rule.define({
+  name: "no-nested-effect-call",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid nesting Effect.* calls. Build values first, then use a flat pipeline.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!isEffectCall(node)) return Effect.void
+
+        const ce = node as ESTree.CallExpression
+        if (!("arguments" in ce) || !Array.isArray(ce.arguments)) return Effect.void
+
+        for (const arg of ce.arguments) {
+          if (isEffectCall(arg)) {
+            return ctx.report(
+              Diagnostic.make({
+                node,
+                message:
+                  "Nested Effect.* call detected. Build values first, then use a flat pipeline.",
+              }),
+            )
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})