@yasainet/eslint 0.0.68 → 0.0.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yasainet/eslint",
-  "version": "0.0.68",
+  "version": "0.0.70",
   "description": "ESLint",
   "type": "module",
   "exports": {

package/src/common/imports.mjs

@@ -56,6 +56,16 @@ const LATERAL_PATTERNS = {
       message:
         "entries cannot import other feature's entries (lateral violation)",
     },
+    {
+      group: [
+        "@/features/*/services/*",
+        "@/features/*/services",
+        "!@/features/shared/services/*",
+        "!@/features/shared/services",
+      ],
+      message:
+        "entries cannot import other feature's services. Use the same feature's service (1:1) or move orchestration into the service layer. `shared/services/*` is exempt for cross-cutting side effects (notifications etc.).",
+    },
   ],
 };
 

package/src/common/local-plugins/entry-single-service-call.mjs

@@ -0,0 +1,97 @@
+/**
+ * Enforce 1:1 entry-to-service mapping for `**\/entries/*.ts` exports.
+ *
+ * Why: services are the orchestration layer (they may combine multiple queries
+ * and other features' queries). entries should be a thin wrapper that calls a
+ * single service function and normalizes the return shape into
+ * `{ data, error }`. If an entry calls more than one service, orchestration is
+ * leaking up into the entry layer.
+ *
+ * Detection rule:
+ *
+ * - For every exported async `FunctionDeclaration` in an entries file, count
+ *   `CallExpression`s whose callee is a `MemberExpression` of the form
+ *   `<binding>.<method>(...)` where `<binding>` matches the namespace import
+ *   naming convention `*Service` (e.g. `articlesServerService`,
+ *   `usersClientService`).
+ * - More than one such call inside the same exported function is an error.
+ *
+ * Exception (C-3):
+ *
+ * - Bindings starting with `shared` (e.g. `sharedDiscordService`,
+ *   `sharedResendService`) are EXCLUDED from the count. These represent
+ *   cross-cutting side-effect abstractions (Discord / Resend / Slack
+ *   notifications) that don't fit the entry-service 1:1 model and are allowed
+ *   to be invoked from entries directly.
+ *
+ * The rule reports the 2nd and later violations (the 1st call is permitted),
+ * so the fix surface is the redundant calls.
+ */
+
+const SERVICE_BINDING_REGEX = /Service$/;
+
+function isServiceCall(node) {
+  if (node?.type !== "CallExpression") return false;
+  const callee = node.callee;
+  if (callee.type !== "MemberExpression") return false;
+  const obj = callee.object;
+  if (obj.type !== "Identifier") return false;
+  if (!SERVICE_BINDING_REGEX.test(obj.name)) return false;
+  if (obj.name.startsWith("shared")) return false;
+  return true;
+}
+
+function collectServiceCalls(root) {
+  const calls = [];
+  function visit(node) {
+    if (!node || typeof node !== "object") return;
+    if (isServiceCall(node)) calls.push(node);
+    for (const key of Object.keys(node)) {
+      if (key === "parent" || key === "loc" || key === "range") continue;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        for (const item of value) visit(item);
+      } else if (value && typeof value === "object" && "type" in value) {
+        visit(value);
+      }
+    }
+  }
+  visit(root);
+  return calls;
+}
+
+export const entrySingleServiceCallRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Enforce entries call at most one (non-shared) feature service per exported function.",
+    },
+    messages: {
+      multipleServiceCalls:
+        "entry '{{ funcName }}' calls more than one feature service ({{ count }} total). entries must be a thin wrapper that calls a single service. Move orchestration into the service layer. `shared/services/*` (e.g. `sharedDiscordService`) is exempt.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ExportNamedDeclaration(node) {
+        if (!node.declaration) return;
+        const decl = node.declaration;
+        if (decl.type !== "FunctionDeclaration") return;
+        if (!decl.async) return;
+        if (!decl.id) return;
+        const funcName = decl.id.name;
+        const calls = collectServiceCalls(decl.body);
+        if (calls.length <= 1) return;
+        for (let i = 1; i < calls.length; i++) {
+          context.report({
+            node: calls[i],
+            messageId: "multipleServiceCalls",
+            data: { funcName, count: String(calls.length) },
+          });
+        }
+      },
+    };
+  },
+};

package/src/common/local-plugins/index.mjs

@@ -1,3 +1,4 @@
+import { entrySingleServiceCallRule } from "./entry-single-service-call.mjs";
 import { entryTemplateRule } from "./entry-template.mjs";
 import { featureNameRule } from "./feature-name.mjs";
 import { formStateNamingRule } from "./form-state-naming.mjs";
@@ -14,6 +15,7 @@ import { supabaseSelectTypedColumnsRule } from "./supabase-select-typed-columns.
 /** Single plugin object to avoid ESLint "Cannot redefine plugin" errors. */
 export const localPlugin = {
   rules: {
+    "entry-single-service-call": entrySingleServiceCallRule,
     "entry-template": entryTemplateRule,
     "feature-name": featureNameRule,
     "form-state-naming": formStateNamingRule,

package/src/common/naming.mjs

@@ -305,6 +305,15 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
     },
   });
 
+  configs.push({
+    name: "naming/entry-single-service-call",
+    files: featuresGlob(featureRoot, "**/entries/*.ts"),
+    plugins: { local: localPlugin },
+    rules: {
+      "local/entry-single-service-call": "error",
+    },
+  });
+
   configs.push(
     {
       name: "naming/entries-shared",

package/src/next/tailwindcss.mjs

@@ -1,5 +1,32 @@
+import { existsSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
+
 import betterTailwindcss from "eslint-plugin-better-tailwindcss";
 
+// `eslint-plugin-better-tailwindcss` resolves a relative `entryPoint` against
+// the linter's `cwd`, which under LSP servers (vscode-eslint, Zed) is often
+// the edited file's directory rather than the consumer's project root and
+// breaks resolution. Mirror the `findProjectRoot` pattern from
+// `common/rules.mjs` and `common/constants.mjs`: walk up from this module
+// outside of `node_modules` and locate `src/app/globals.css`, then pass the
+// absolute path so resolution is cwd-independent. Falls back to the relative
+// path when not found, preserving the previous CLI-only behavior.
+const findEntryPoint = (start) => {
+  let dir = start;
+  while (dir !== dirname(dir)) {
+    if (!dir.split(sep).includes("node_modules")) {
+      const candidate = join(dir, "src/app/globals.css");
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    dir = dirname(dir);
+  }
+  return "src/app/globals.css";
+};
+
+const entryPoint = findEntryPoint(import.meta.dirname);
+
 /**
  * Tailwind CSS v4 lint rules:
  *
@@ -9,9 +36,9 @@ import betterTailwindcss from "eslint-plugin-better-tailwindcss";
  *   (`-space-x-2`) remain allowed for intentional overlap
  * - class order, deprecated classes, conflicts, duplicates, and whitespace
  *   are enforced via `eslint-plugin-better-tailwindcss`
- * - `entryPoint` points at the consuming project's CSS-first Tailwind config
- *   (`src/app/globals.css`). Override in the project's eslint.config.mjs if
- *   the path differs.
+ * - `entryPoint` is auto-resolved to the consuming project's
+ *   `src/app/globals.css` via walk-up from this module. Override in the
+ *   project's eslint.config.mjs if the file lives elsewhere.
  */
 export const tailwindcssConfigs = [
   {
@@ -20,7 +47,7 @@ export const tailwindcssConfigs = [
     plugins: { "better-tailwindcss": betterTailwindcss },
     settings: {
       "better-tailwindcss": {
-        entryPoint: "src/app/globals.css",
+        entryPoint,
       },
     },
     rules: {