@aas-dev/stack 0.0.0-stage → 0.1.1

package/plugin/aas.mjs

@@ -0,0 +1,572 @@
+const markers = [
+  "@ts-ignore",
+  "@ts-expect-error",
+  "@ts-nocheck",
+  "eslint-disable",
+  "eslint-enable",
+  "oxlint-disable",
+  "oxlint-enable",
+]
+
+const errorNames = new Set([
+  "Error",
+  "AggregateError",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+])
+
+const rawSpecifiers = new Set([
+  "child_process",
+  "fs",
+  "http",
+  "https",
+  "node:child_process",
+  "node:fs",
+  "node:fs/promises",
+  "node:http",
+  "node:https",
+])
+
+const socketSpecifiers = new Set(["net", "node:net", "node:tls", "tls"])
+
+const consoleMethods = new Set(["debug", "error", "info", "log", "warn"])
+
+const effectRunMethods = new Set(["runFork", "runPromise", "runPromiseExit", "runSync"])
+
+const bannedTestMembers = new Set(["only", "skip", "skipIf", "todo"])
+
+const testAliases = new Set(["fdescribe", "fit", "ftest", "xdescribe", "xit", "xtest"])
+
+const report = (context, node, message) => {
+  context.report({ node, message })
+}
+
+const literalName = (property, computed) => {
+  if (!computed && property.type === "Identifier") {
+    return property.name
+  }
+  if (
+    computed &&
+    (property.type === "Literal" || property.type === "StringLiteral") &&
+    typeof property.value === "string"
+  ) {
+    return property.value
+  }
+  return ""
+}
+
+const isProcessEnv = (node) => {
+  if (node.type !== "MemberExpression") {
+    return false
+  }
+  return (
+    node.object.type === "Identifier" &&
+    node.object.name === "process" &&
+    literalName(node.property, node.computed) === "env"
+  )
+}
+
+const hasName = (node, name) => {
+  if (node === null || node === undefined || typeof node !== "object") {
+    return false
+  }
+  if (node.type === "Identifier" && node.name === name) {
+    return true
+  }
+  return (
+    hasName(node.callee, name) ||
+    hasName(node.object, name) ||
+    hasName(node.property, name) ||
+    hasName(node.expression, name)
+  )
+}
+
+const blessedSuper = (node) => hasName(node, "TaggedError") || hasName(node, "Service")
+
+const specifier = (node) => {
+  if (node === null || node === undefined) {
+    return ""
+  }
+  if (
+    (node.type === "Literal" || node.type === "StringLiteral") &&
+    typeof node.value === "string"
+  ) {
+    return node.value
+  }
+  return ""
+}
+
+const chainParts = (callee) => {
+  const parts = []
+  let current = callee
+  while (current.type === "MemberExpression" || current.type === "ChainExpression") {
+    if (current.type === "ChainExpression") {
+      current = current.expression
+      continue
+    }
+    if (current.computed || current.property.type !== "Identifier") {
+      return []
+    }
+    parts.push(current.property.name)
+    current = current.object
+  }
+  if (current.type !== "Identifier") {
+    return []
+  }
+  parts.push(current.name)
+  parts.reverse()
+  return parts
+}
+
+const isItEffect = (parts) => {
+  if (parts[0] !== "it" || parts[1] !== "effect") {
+    return false
+  }
+  let index = 2
+  while (index < parts.length) {
+    const part = parts[index]
+    if (part !== undefined && bannedTestMembers.has(part)) {
+      return false
+    }
+    index += 1
+  }
+  return true
+}
+
+const flagModuleBinding = (context, statement) => {
+  if (statement === null || statement === undefined) {
+    return
+  }
+  if (statement.type === "VariableDeclaration" && statement.kind !== "const") {
+    report(
+      context,
+      statement,
+      "module-scope let and var are banned; keep state in a Context.Service",
+    )
+  }
+  const binding = statement.init ?? statement.left
+  if (
+    (statement.type === "ForStatement" ||
+      statement.type === "ForInStatement" ||
+      statement.type === "ForOfStatement") &&
+    binding !== null &&
+    binding !== undefined &&
+    binding.type === "VariableDeclaration" &&
+    binding.kind !== "const"
+  ) {
+    report(context, binding, "module-scope let and var are banned; keep state in a Context.Service")
+  }
+}
+
+const noThrow = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      ThrowStatement(node) {
+        report(context, node, "throw is banned; yield a Schema.TaggedError")
+      },
+    }
+  },
+}
+
+const noTry = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      TryStatement(node) {
+        report(context, node, "try is banned; failures stay on the Effect channel")
+      },
+    }
+  },
+}
+
+const noErrorClass = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      NewExpression(node) {
+        const callee = node.callee
+        const name =
+          callee.type === "Identifier"
+            ? callee.name
+            : callee.type === "MemberExpression"
+              ? literalName(callee.property, callee.computed)
+              : ""
+        if (errorNames.has(name)) {
+          report(context, node, "new Error is banned; define a Schema.TaggedError")
+        }
+      },
+    }
+  },
+}
+
+const noProcessEnv = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if (isProcessEnv(node)) {
+          report(
+            context,
+            node,
+            "process.env is banned; declare the variable in .env.schema and read it with Config",
+          )
+        }
+      },
+    }
+  },
+}
+
+const noTypeAssertion = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      TSAsExpression(node) {
+        report(
+          context,
+          node,
+          "type assertions are banned, including as const; parse with Schema or use a const type parameter",
+        )
+      },
+      TSTypeAssertion(node) {
+        report(
+          context,
+          node,
+          "angle-bracket assertions are banned; parse with Schema or use a const type parameter",
+        )
+      },
+    }
+  },
+}
+
+const noExplicitAny = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      TSAnyKeyword(node) {
+        report(context, node, "any is banned; use unknown and decode it with Schema")
+      },
+    }
+  },
+}
+
+const noNonNullAssertion = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      TSNonNullExpression(node) {
+        report(
+          context,
+          node,
+          "non-null assertions are banned; narrow the value or decode it with Schema",
+        )
+      },
+    }
+  },
+}
+
+const textOf = (context) => {
+  const source = context.sourceCode
+  if (typeof source.text === "string") {
+    return source.text
+  }
+  if (typeof source.getText === "function") {
+    return source.getText()
+  }
+  return ""
+}
+
+const commentStart = (comment) => {
+  const range = comment.range
+  if (Array.isArray(range)) {
+    const start = range[0]
+    return typeof start === "number" ? start : -1
+  }
+  if (range !== null && range !== undefined && typeof range.start === "number") {
+    return range.start
+  }
+  if (typeof comment.start === "number") {
+    return comment.start
+  }
+  return -1
+}
+
+const isShebang = (comment, text) => {
+  if (comment.type === "Shebang" || comment.type === "Hashbang") {
+    return true
+  }
+  return text.startsWith("#!") && commentStart(comment) === 0
+}
+
+const noComments = {
+  meta: { type: "problem" },
+  create(context) {
+    const text = textOf(context)
+    return {
+      Program(node) {
+        for (const comment of context.sourceCode.getAllComments()) {
+          if (isShebang(comment, text)) {
+            continue
+          }
+          const message = "comments are banned; use clearer names or docs"
+          if (comment.loc === undefined || comment.loc === null) {
+            report(context, node, message)
+          } else {
+            context.report({ loc: comment.loc, message })
+          }
+        }
+      },
+    }
+  },
+}
+
+const noBypassComment = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      Program(node) {
+        for (const comment of context.sourceCode.getAllComments()) {
+          let matched = ""
+          for (const marker of markers) {
+            if (comment.value.includes(marker)) {
+              matched = marker
+              break
+            }
+          }
+          if (matched === "") {
+            continue
+          }
+          const message = `directive comments are banned (${matched})`
+          if (comment.loc === undefined || comment.loc === null) {
+            report(context, node, message)
+          } else {
+            context.report({ loc: comment.loc, message })
+          }
+        }
+      },
+    }
+  },
+}
+
+const effectTests = {
+  meta: { type: "problem" },
+  create(context) {
+    const filename = typeof context.filename === "string" ? context.filename : ""
+    const isTest = filename.endsWith(".test.ts")
+    return {
+      ImportDeclaration(node) {
+        const source = specifier(node.source)
+        if (source === "vitest/config") {
+          if (!filename.endsWith("/vitest.config.ts") && !filename.endsWith("\\vitest.config.ts")) {
+            report(context, node, "import tests from @effect/vitest")
+          }
+          return
+        }
+        if (source === "vitest" || source.startsWith("vitest/") || source.startsWith("@vitest/")) {
+          report(context, node, "import tests from @effect/vitest")
+        }
+      },
+      CallExpression(node) {
+        if (!isTest) {
+          return
+        }
+        const parts = chainParts(node.callee)
+        const root = parts[0]
+        if (root === undefined) {
+          if (
+            node.callee.type === "Identifier" &&
+            (node.callee.name === "it" ||
+              node.callee.name === "test" ||
+              testAliases.has(node.callee.name))
+          ) {
+            report(context, node, "tests use it.effect from @effect/vitest")
+          }
+          return
+        }
+        if (isItEffect(parts)) {
+          return
+        }
+        if (root === "it" || root === "test" || testAliases.has(root)) {
+          report(context, node, "tests use it.effect from @effect/vitest")
+          return
+        }
+        if (root === "describe") {
+          let index = 1
+          while (index < parts.length) {
+            const part = parts[index]
+            if (part !== undefined && bannedTestMembers.has(part)) {
+              report(context, node, "skipped, focused, and todo tests are banned")
+              return
+            }
+            index += 1
+          }
+        }
+      },
+    }
+  },
+}
+
+const isAdapterFile = (context) => {
+  const filename = typeof context.filename === "string" ? context.filename : ""
+  return filename.endsWith(".adapter.ts")
+}
+
+const rawMessage = (source) => {
+  if (socketSpecifiers.has(source)) {
+    return "node:net and node:tls belong in a .adapter.ts file; other raw IO stays banned"
+  }
+  return "raw IO imports are banned; use Effect FileSystem, HttpClient, or ChildProcess"
+}
+
+const bannedRaw = (context, node, source) => {
+  if (socketSpecifiers.has(source)) {
+    if (isAdapterFile(context)) {
+      return
+    }
+    report(context, node, rawMessage(source))
+    return
+  }
+  if (rawSpecifiers.has(source)) {
+    report(context, node, rawMessage(source))
+  }
+}
+
+const noRawIo = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        bannedRaw(context, node, specifier(node.source))
+      },
+      ImportExpression(node) {
+        bannedRaw(context, node, specifier(node.source))
+      },
+      CallExpression(node) {
+        const callee = node.callee
+        if (callee.type === "Identifier" && callee.name === "fetch") {
+          report(context, node, "global fetch is banned; use Effect HttpClient")
+          return
+        }
+        if (callee.type === "Identifier" && callee.name === "require") {
+          bannedRaw(context, node, specifier(node.arguments[0]))
+          return
+        }
+        if (callee.type !== "MemberExpression") {
+          return
+        }
+        const name = literalName(callee.property, callee.computed)
+        if (
+          callee.object.type === "Identifier" &&
+          callee.object.name === "console" &&
+          consoleMethods.has(name)
+        ) {
+          report(context, node, "console is banned; use Effect Console")
+          return
+        }
+        if (
+          callee.object.type === "Identifier" &&
+          (callee.object.name === "globalThis" ||
+            callee.object.name === "global" ||
+            callee.object.name === "window") &&
+          name === "fetch"
+        ) {
+          report(context, node, "global fetch is banned; use Effect HttpClient")
+        }
+      },
+    }
+  },
+}
+
+const noEffectRun = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee
+        if (callee.type !== "MemberExpression") {
+          return
+        }
+        if (
+          callee.object.type === "Identifier" &&
+          callee.object.name === "Effect" &&
+          effectRunMethods.has(literalName(callee.property, callee.computed))
+        ) {
+          report(
+            context,
+            node,
+            "Effect.run* is banned; stay inside Effect and use it.effect in tests",
+          )
+        }
+      },
+    }
+  },
+}
+
+const noModuleLet = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      Program(node) {
+        for (const statement of node.body) {
+          const declaration =
+            statement.type === "ExportNamedDeclaration" ? statement.declaration : statement
+          flagModuleBinding(context, declaration)
+        }
+      },
+    }
+  },
+}
+
+const noPlainClass = {
+  meta: { type: "problem" },
+  create(context) {
+    return {
+      ClassDeclaration(node) {
+        if (!blessedSuper(node.superClass)) {
+          report(
+            context,
+            node,
+            "plain classes are banned; extend Schema.TaggedError or Context.Service",
+          )
+        }
+      },
+      ClassExpression(node) {
+        if (!blessedSuper(node.superClass)) {
+          report(
+            context,
+            node,
+            "plain classes are banned; extend Schema.TaggedError or Context.Service",
+          )
+        }
+      },
+    }
+  },
+}
+
+const rules = {
+  "effect-tests": effectTests,
+  "no-bypass-comment": noBypassComment,
+  "no-comments": noComments,
+  "no-effect-run": noEffectRun,
+  "no-error-class": noErrorClass,
+  "no-explicit-any": noExplicitAny,
+  "no-module-let": noModuleLet,
+  "no-non-null-assertion": noNonNullAssertion,
+  "no-plain-class": noPlainClass,
+  "no-process-env": noProcessEnv,
+  "no-raw-io": noRawIo,
+  "no-throw": noThrow,
+  "no-try": noTry,
+  "no-type-assertion": noTypeAssertion,
+}
+
+export const ruleNames = Object.keys(rules)
+
+export default {
+  meta: { name: "aas" },
+  rules,
+}