oxlint-plugin-effect 0.0.0

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

@@ -0,0 +1,44 @@
+/**
+ * Ban nested `Effect.gen` calls.
+ *
+ * An `Effect.gen` inside another `Effect.gen` should be flattened.
+ *
+ * Sources: biome-effect-linting-rules/no-nested-effect-gen, language-service/nestedEffectGenYield
+ */
+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"
+
+export const noNestedEffectGen = Rule.define({
+  name: "no-nested-effect-gen",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid nested Effect.gen. Flatten to a single Effect.gen per method.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    const depth = yield* Ref.make(0)
+
+    return Visitor.merge(
+      Visitor.tracked("CallExpression", (node) => AST.isCallOf(node, "Effect", "gen"), depth),
+      {
+        CallExpression: (node) =>
+          Effect.flatMap(Ref.get(depth), (d) => {
+            if (d > 1 && AST.isCallOf(node as ESTree.CallExpression, "Effect", "gen")) {
+              return ctx.report(
+                Diagnostic.make({
+                  node,
+                  message:
+                    "Nested Effect.gen detected. Flatten to a single Effect.gen.",
+                }),
+              )
+            }
+            return Effect.void
+          }),
+      },
+    )
+  },
+})

package/src/rules/no-nested-pipe.ts

@@ -0,0 +1,76 @@
+/**
+ * Ban nested `pipe()` calls — `pipe(pipe(...), ...)` or `.pipe(...).pipe(...)`.
+ *
+ * Flatten into a single pipeline.
+ *
+ * Sources: biome-effect-linting-rules/no-pipe-ladder, language-service/unnecessaryPipeChain
+ */
+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 { pipe } from "effect/Function"
+
+const isPipeCall = (node: ESTree.Node): boolean => {
+  if (node.type === "CallExpression" && "callee" in node) {
+    const callee = (node as unknown as Record<string, unknown>)["callee"]
+    if (callee != null && typeof callee === "object" && "type" in callee) {
+      // pipe(...)
+      if (callee.type === "Identifier" && "name" in callee && callee.name === "pipe") {
+        return true
+      }
+      // x.pipe(...)
+      if (
+        callee.type === "MemberExpression" &&
+        "property" in callee &&
+        callee.property != null &&
+        typeof callee.property === "object" &&
+        "type" in callee.property &&
+        callee.property.type === "Identifier" &&
+        "name" in callee.property &&
+        callee.property.name === "pipe"
+      ) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+export const noNestedPipe = Rule.define({
+  name: "no-nested-pipe",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid nested pipe() calls. Flatten into a single pipeline.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!isPipeCall(node)) return Effect.void
+
+        // Check if any argument is itself a pipe call
+        if ("arguments" in node && Array.isArray(node.arguments)) {
+          for (const arg of node.arguments) {
+            if (
+              arg != null &&
+              typeof arg === "object" &&
+              "type" in arg &&
+              isPipeCall(arg as unknown as ESTree.Node)
+            ) {
+              return ctx.report(
+                Diagnostic.make({
+                  node: arg,
+                  message:
+                    "Nested pipe() detected. Flatten into a single pipeline.",
+                }),
+              )
+            }
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-new-error.ts

@@ -0,0 +1,17 @@
+/**
+ * Ban `new Error(...)`.
+ *
+ * Use Schema.TaggedErrorClass or Data.TaggedError instead.
+ *
+ * Source: language-service/globalErrorInEffectFailure, extendsNativeError
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noNewError = Rule.banNewExpr(
+  ["Error", "TypeError", "RangeError", "ReferenceError", "SyntaxError"],
+  {
+    message:
+      "Avoid native Error constructors. Use Schema.TaggedErrorClass or Data.TaggedError.",
+    meta: { type: "suggestion" },
+  },
+)

package/src/rules/no-new-promise.ts

@@ -0,0 +1,14 @@
+/**
+ * Ban `new Promise(...)`.
+ *
+ * Use Effect.async, Effect.tryPromise, or Effect.promise instead.
+ *
+ * Source: language-service/newPromise
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noNewPromise = Rule.banNewExpr("Promise", {
+  message:
+    "Avoid new Promise(). Use Effect.async, Effect.tryPromise, or Effect.promise.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-node-builtin-import.ts

@@ -0,0 +1,70 @@
+/**
+ * Ban Node.js builtin imports.
+ *
+ * Use Effect platform services: FileSystem, Path, HttpClient, Command.
+ *
+ * Source: language-service/nodeBuiltinImport
+ */
+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 hints: Record<string, string> = {
+  fs: "Use FileSystem from 'effect'",
+  path: "Use Path from 'effect'",
+  http: "Use HttpClient from 'effect/unstable/http'",
+  https: "Use HttpClient from 'effect/unstable/http'",
+  child_process: "Use Command from 'effect'",
+  crypto: "Use a service wrapper",
+  os: "Use PlatformInfo from 'effect'",
+  net: "Use HttpServer from 'effect/unstable/http'",
+  dns: "Use a service wrapper",
+  tls: "Use a service wrapper",
+  dgram: "Use a service wrapper",
+  stream: "Use Stream from 'effect'",
+  zlib: "Use a service wrapper",
+  readline: "Use Terminal from 'effect'",
+  cluster: "Use a service wrapper",
+  worker_threads: "Use a service wrapper",
+}
+
+const nodeBuiltins = new Set(Object.keys(hints))
+
+const resolveModule = (source: string): string | undefined => {
+  const name = source.startsWith("node:") ? source.slice(5) : source
+  const base = name.split("/")[0]
+  return base !== undefined && nodeBuiltins.has(base) ? base : undefined
+}
+
+export const noNodeBuiltinImport = Rule.define({
+  name: "no-node-builtin-import",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Node.js builtin imports. Use Effect platform services.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      ImportDeclaration: (node) => {
+        const source = Option.getOrUndefined(
+          AST.narrow(node, "ImportDeclaration").pipe(Option.map(AST.importSource)),
+        )
+        if (source === undefined) return Effect.void
+
+        const mod = resolveModule(source)
+        if (mod === undefined) return Effect.void
+
+        const hint = hints[mod] ?? "Use an Effect service wrapper"
+        return ctx.report(
+          Diagnostic.make({
+            node,
+            message: `Avoid importing '${source}'. ${hint}.`,
+          }),
+        )
+      },
+    }
+  },
+})

package/src/rules/no-option-as.ts

@@ -0,0 +1,13 @@
+/**
+ * Ban `Option.as`.
+ *
+ * Use `Option.map` or `Option.match` with explicit value return.
+ *
+ * Source: biome-effect-linting-rules/no-option-as
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noOptionAs = Rule.banMember("Option", "as", {
+  message: "Avoid Option.as. Use Option.map or Option.match instead.",
+  meta: { type: "suggestion" },
+})

package/src/rules/no-option-boolean-normalization.ts

@@ -0,0 +1,89 @@
+/**
+ * Ban `Option.match(x, { onSome: (v) => v === true, onNone: () => false })`.
+ *
+ * Normalize at the schema boundary instead.
+ *
+ * Source: biome-effect-linting-rules/no-option-boolean-normalization
+ */
+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 noOptionBooleanNormalization = Rule.define({
+  name: "no-option-boolean-normalization",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid Option.match for boolean normalization. Normalize at schema boundary.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      CallExpression: (node) => {
+        if (!AST.isCallOf(node as ESTree.CallExpression, "Option", "match")) return Effect.void
+
+        if (!("arguments" in node) || !Array.isArray(node.arguments) || node.arguments.length < 2)
+          return Effect.void
+
+        const opts = node.arguments[1]
+        if (opts == null || typeof opts !== "object" || !("type" in opts)) return Effect.void
+        if (opts.type !== "ObjectExpression" || !("properties" in opts) || !Array.isArray(opts.properties))
+          return Effect.void
+
+        let hasTripleEqualTrue = false
+        let hasReturnFalse = false
+
+        for (const prop of opts.properties) {
+          if (prop == null || typeof prop !== "object" || !("type" in prop) || prop.type !== "Property")
+            continue
+          const key = (prop as unknown as Record<string, unknown>)["key"] as unknown as Record<string, unknown> | null
+          const value = (prop as unknown as Record<string, unknown>)["value"] as unknown as Record<string, unknown> | null
+
+          if (key == null || value == null) continue
+
+          // onSome: (v) => v === true
+          if (
+            key["type"] === "Identifier" && key["name"] === "onSome" &&
+            value["type"] === "ArrowFunctionExpression" && "body" in value
+          ) {
+            const body = value["body"] as unknown as Record<string, unknown> | null
+            if (
+              body != null &&
+              body["type"] === "BinaryExpression" &&
+              body["operator"] === "===" &&
+              "right" in body
+            ) {
+              const right = body["right"] as unknown as Record<string, unknown> | null
+              if (right != null && right["type"] === "Literal" && right["value"] === true) {
+                hasTripleEqualTrue = true
+              }
+            }
+          }
+
+          // onNone: () => false
+          if (
+            key["type"] === "Identifier" && key["name"] === "onNone" &&
+            value["type"] === "ArrowFunctionExpression" && "body" in value
+          ) {
+            const body = value["body"] as unknown as Record<string, unknown> | null
+            if (body != null && body["type"] === "Literal" && body["value"] === false) {
+              hasReturnFalse = true
+            }
+          }
+        }
+
+        if (hasTripleEqualTrue && hasReturnFalse) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Avoid Option.match for boolean normalization. Normalize at schema boundary instead.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-platform-globals.ts

@@ -0,0 +1,117 @@
+/**
+ * Ban platform-specific global access inside Effect.gen/fn context.
+ *
+ * Catches `Bun.*`, `process.*`, `Deno.*` — any runtime-specific API
+ * that should be wrapped in an Effect service for testability and portability.
+ *
+ * Provides Effect alternative hints where known.
+ *
+ * Sources: language-service/processEnv, processEnvInEffect + generalized
+ */
+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"
+
+const platformObjects = new Set(["Bun", "process", "Deno"])
+
+/**
+ * Map of `Object.property` → Effect alternative hint.
+ * Falls back to a generic message for unknown properties.
+ */
+const alternatives: Record<string, Record<string, string>> = {
+  Bun: {
+    file: "Use FileSystem from 'effect'",
+    write: "Use FileSystem from 'effect'",
+    read: "Use FileSystem from 'effect'",
+    serve: "Use HttpServer from 'effect/unstable/http'",
+    env: "Use Config from 'effect'",
+    spawn: "Use Command from 'effect'",
+    sleep: "Use Effect.sleep",
+    stdin: "Use Terminal from 'effect'",
+    stdout: "Use Terminal from 'effect'",
+    stderr: "Use Terminal from 'effect'",
+    cwd: "Use Path from 'effect'",
+    which: "Use Command from 'effect'",
+    resolveSync: "Use Path from 'effect'",
+    pathToFileURL: "Use Path from 'effect'",
+  },
+  process: {
+    env: "Use Config from 'effect'",
+    exit: "Use Effect.fail or Effect.die",
+    cwd: "Use Path from 'effect'",
+    argv: "Use Args/Command from 'effect/unstable/cli'",
+    stdin: "Use Terminal from 'effect'",
+    stdout: "Use Terminal from 'effect'",
+    stderr: "Use Terminal from 'effect'",
+    chdir: "Use Path from 'effect'",
+    kill: "Use Command from 'effect'",
+    on: "Use Effect.async or Stream.async",
+    platform: "Use PlatformInfo from 'effect'",
+    arch: "Use PlatformInfo from 'effect'",
+    execPath: "Use Command from 'effect'",
+    execArgv: "Use Args/Command from 'effect/unstable/cli'",
+  },
+  Deno: {
+    readFile: "Use FileSystem from 'effect'",
+    writeFile: "Use FileSystem from 'effect'",
+    readTextFile: "Use FileSystem from 'effect'",
+    writeTextFile: "Use FileSystem from 'effect'",
+    open: "Use FileSystem from 'effect'",
+    remove: "Use FileSystem from 'effect'",
+    mkdir: "Use FileSystem from 'effect'",
+    readDir: "Use FileSystem from 'effect'",
+    stat: "Use FileSystem from 'effect'",
+    cwd: "Use Path from 'effect'",
+    env: "Use Config from 'effect'",
+    exit: "Use Effect.fail or Effect.die",
+    serve: "Use HttpServer from 'effect/unstable/http'",
+    run: "Use Command from 'effect'",
+    args: "Use Args/Command from 'effect/unstable/cli'",
+  },
+}
+
+function getHint(obj: string, prop: string): string {
+  const hint = alternatives[obj]?.[prop]
+  if (hint) return `. ${hint}`
+  return ". Wrap in a service for testability"
+}
+
+export const noPlatformGlobals = Rule.define({
+  name: "no-platform-globals",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid platform globals (Bun.*, process.*, Deno.*) inside Effect context. Use Effect platform services.",
+  }),
+  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) return Effect.void
+
+          const names = Option.getOrUndefined(
+            AST.memberNames(node as ESTree.MemberExpression),
+          )
+          if (names === undefined) return Effect.void
+
+          const [obj, prop] = names
+          if (!platformObjects.has(obj)) return Effect.void
+
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message: `Avoid ${obj}.${prop} inside Effect context${getHint(obj, prop)}.`,
+            }),
+          )
+        }),
+    })
+  },
+})

package/src/rules/no-process-env-in-effect.ts

@@ -0,0 +1,39 @@
+/**
+ * Ban `process.env` inside Effect.gen/fn context.
+ *
+ * Use Effect Config service instead.
+ *
+ * Source: language-service/processEnvInEffect
+ */
+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 noProcessEnvInEffect = Rule.define({
+  name: "no-process-env-in-effect",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid process.env inside Effect.gen/fn. Use Config service.",
+  }),
+  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, "process", "env"))) {
+            return ctx.report(
+              Diagnostic.make({ node, message: "Avoid process.env inside Effect context. Use Config service." }),
+            )
+          }
+          return Effect.void
+        }),
+    })
+  },
+})

package/src/rules/no-process-env.ts

@@ -0,0 +1,13 @@
+/**
+ * Ban `process.env` access.
+ *
+ * Use Effect Config service instead.
+ *
+ * Source: language-service/processEnv
+ */
+import { Rule } from "../vendor/effect-oxlint/index.js"
+
+export const noProcessEnv = Rule.banMember("process", "env", {
+  message: "Avoid process.env. Use Effect Config service.",
+  meta: { type: "suggestion" },
+})

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

@@ -0,0 +1,39 @@
+/**
+ * Ban `Math.random()` inside Effect.gen/fn context.
+ *
+ * Use Random service instead.
+ *
+ * Source: language-service/globalRandomInEffect
+ */
+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 noRandomInEffect = Rule.define({
+  name: "no-random-in-effect",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Avoid Math.random() inside Effect.gen/fn. Use Random service.",
+  }),
+  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, "Math", "random"))) {
+            return ctx.report(
+              Diagnostic.make({ node, message: "Avoid Math.random() inside Effect context. Use Random service." }),
+            )
+          }
+          return Effect.void
+        }),
+    })
+  },
+})

package/src/rules/no-return-in-arrow.ts

@@ -0,0 +1,77 @@
+/**
+ * Ban explicit `return` in arrow function callbacks (info severity).
+ *
+ * Use expression-only callbacks + pipeline logic.
+ * Excludes Schema.filter callbacks where return is required.
+ *
+ * Source: biome-effect-linting-rules/no-return-in-arrow
+ */
+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 noReturnInArrow = Rule.define({
+  name: "no-return-in-arrow",
+  meta: Rule.meta({
+    type: "suggestion",
+    description: "Prefer expression-only arrow callbacks. Avoid explicit return in arrow functions.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      ArrowFunctionExpression: (node) => {
+        if (
+          "body" in node &&
+          node.body != null &&
+          typeof node.body === "object" &&
+          "type" in node.body &&
+          node.body.type === "BlockStatement" &&
+          "body" in node.body &&
+          Array.isArray(node.body.body)
+        ) {
+          for (const stmt of node.body.body) {
+            if (
+              stmt != null &&
+              typeof stmt === "object" &&
+              "type" in stmt &&
+              stmt.type === "ReturnStatement"
+            ) {
+              // Check if parent is a Schema.filter call — skip those
+              if (
+                "parent" in node &&
+                node.parent != null &&
+                typeof node.parent === "object" &&
+                "type" in node.parent &&
+                node.parent.type === "CallExpression" &&
+                "callee" in node.parent
+              ) {
+                const callee = node.parent.callee
+                if (
+                  callee != null &&
+                  typeof callee === "object" &&
+                  "type" in callee &&
+                  callee.type === "MemberExpression" &&
+                  "property" in callee &&
+                  callee.property != null &&
+                  typeof callee.property === "object" &&
+                  "name" in callee.property &&
+                  (callee.property.name === "filter" || callee.property.name === "check")
+                ) {
+                  return Effect.void
+                }
+              }
+
+              return ctx.report(
+                Diagnostic.make({
+                  node: stmt,
+                  message: "Prefer expression-only arrow callbacks over explicit return.",
+                }),
+              )
+            }
+          }
+        }
+        return Effect.void
+      },
+    }
+  },
+})

package/src/rules/no-return-null.ts

@@ -0,0 +1,47 @@
+/**
+ * Ban `return null` statements.
+ *
+ * Use Option.none for absence or Effect.fail for errors.
+ *
+ * Source: biome-effect-linting-rules/no-return-null
+ */
+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 { pipe } from "effect/Function"
+
+export const noReturnNull = Rule.define({
+  name: "no-return-null",
+  meta: Rule.meta({
+    type: "suggestion",
+    description:
+      "Avoid returning null. Use Option.none for absence or Effect.fail for errors.",
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext
+    return {
+      ReturnStatement: (node) => {
+        if (
+          node.type === "ReturnStatement" &&
+          "argument" in node &&
+          node.argument !== null &&
+          node.argument !== undefined &&
+          "type" in node.argument &&
+          node.argument.type === "Literal" &&
+          "value" in node.argument &&
+          node.argument.value === null
+        ) {
+          return ctx.report(
+            Diagnostic.make({
+              node,
+              message:
+                "Avoid returning null. Use Option.none for absence.",
+            }),
+          )
+        }
+        return Effect.void
+      },
+    }
+  },
+})