@yasainet/eslint 0.0.72 → 0.0.74

package/src/common/layers/entries.mjs

@@ -0,0 +1,168 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import {
+  LIB_BOUNDARY_PATTERNS,
+  MAPPING_PATTERNS,
+} from "../_internal/import-patterns.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+import {
+  aliasDynamicImportMessage,
+  aliasDynamicImportSelector,
+} from "../_internal/selectors.mjs";
+import { localPlugin } from "../local-plugins/index.mjs";
+
+const LAYER_PATTERNS = [
+  {
+    group: ["**/queries/*", "**/queries"],
+    message: "entries cannot import queries (layer violation)",
+  },
+  {
+    group: ["**/hooks/*", "**/hooks"],
+    message: "entries cannot import hooks (layer violation)",
+  },
+];
+
+const LATERAL_PATTERNS = [
+  {
+    group: ["@/features/*/entries/*", "@/features/*/entries"],
+    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.).",
+  },
+];
+
+const CARDINALITY_PATTERNS = {
+  server: [
+    {
+      group: ["**/services/client", "**/services/admin"],
+      message:
+        "server entry can only import server service (cardinality violation)",
+    },
+  ],
+  client: [
+    {
+      group: ["**/services/server", "**/services/admin"],
+      message:
+        "client entry can only import client service (cardinality violation)",
+    },
+  ],
+  admin: [
+    {
+      group: ["**/services/server", "**/services/client"],
+      message:
+        "admin entry can only import admin service (cardinality violation)",
+    },
+  ],
+};
+
+export function createEntriesConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const prefixPattern = hasPrefixes ? `@(${prefixes.join("|")})` : "*";
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  const configs = [
+    {
+      name: "naming/entries",
+      files: featuresGlob(featureRoot, "**/entries/*.ts"),
+      ignores: featuresGlob(featureRoot, "shared/entries/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": prefixPattern },
+        ],
+      },
+    },
+    {
+      name: "naming/entries-shared",
+      files: featuresGlob(featureRoot, "shared/entries/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "naming/entry-template",
+      files: featuresGlob(featureRoot, "**/entries/*.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/entry-template": "error",
+      },
+    },
+    {
+      name: "naming/entry-single-service-call",
+      files: featuresGlob(featureRoot, "**/entries/*.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/entry-single-service-call": "error",
+      },
+    },
+    {
+      name: "layers/entries",
+      files: [`${featureRoot}/**/entries/*.ts`],
+      rules: {
+        "no-restricted-syntax": [
+          "error",
+          {
+            selector: aliasDynamicImportSelector,
+            message: aliasDynamicImportMessage,
+          },
+        ],
+      },
+    },
+    {
+      name: "imports/entries",
+      files: [`${featureRoot}/**/entries/*.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          {
+            patterns: [
+              ...LAYER_PATTERNS,
+              ...LATERAL_PATTERNS,
+              ...LIB_BOUNDARY_PATTERNS,
+              ...MAPPING_PATTERNS,
+            ],
+          },
+        ],
+      },
+    },
+  ];
+
+  for (const prefix of ["server", "client", "admin"]) {
+    configs.push({
+      name: `imports/entries/${prefix}`,
+      files: [`${featureRoot}/**/entries/${prefix}.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          {
+            patterns: [
+              ...LAYER_PATTERNS,
+              ...LATERAL_PATTERNS,
+              ...CARDINALITY_PATTERNS[prefix],
+              ...LIB_BOUNDARY_PATTERNS,
+              ...MAPPING_PATTERNS,
+            ],
+          },
+        ],
+      },
+    });
+  }
+
+  return configs;
+}

package/src/common/layers/lib.mjs

@@ -0,0 +1,18 @@
+import { checkFile } from "../_internal/plugins.mjs";
+
+export function createLibLayerConfigs({ featureRoot }) {
+  const libRoot = featureRoot.replace(/features$/, "lib");
+  return [
+    {
+      name: "naming/lib",
+      files: [`${libRoot}/**/*.ts`],
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": "*" },
+        ],
+      },
+    },
+  ];
+}

package/src/common/layers/queries.mjs

@@ -0,0 +1,183 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import { MAPPING_PATTERNS } from "../_internal/import-patterns.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+import {
+  aliasDynamicImportMessage,
+  aliasDynamicImportSelector,
+  loggerMessage,
+  loggerSelector,
+} from "../_internal/selectors.mjs";
+import { localPlugin } from "../local-plugins/index.mjs";
+
+const LAYER_PATTERNS = [
+  {
+    group: ["**/services/*", "**/services"],
+    message: "queries cannot import services (layer violation)",
+  },
+  {
+    group: ["**/entries/*", "**/entries"],
+    message: "queries cannot import entries (layer violation)",
+  },
+  {
+    group: ["**/hooks/*", "**/hooks"],
+    message: "queries cannot import hooks (layer violation)",
+  },
+];
+
+const LATERAL_PATTERNS = [
+  {
+    group: ["@/features/*/queries/*", "@/features/*/queries"],
+    message:
+      "queries cannot import other feature's queries (lateral violation)",
+  },
+];
+
+function prefixLibPatterns(prefix, mapping) {
+  const prefixes = Object.keys(mapping);
+  const allowedLib = mapping[prefix];
+  return prefixes
+    .filter((p) => p !== prefix)
+    .map((p) => ({
+      group: [`**/lib/${mapping[p]}`, `**/lib/${mapping[p]}/*`],
+      message: `queries/${prefix}.ts can only import from lib/${allowedLib}. Use the correct query file for this lib.`,
+    }));
+}
+
+export function createQueriesConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const prefixPattern = hasPrefixes ? `@(${prefixes.join("|")})` : "*";
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  const configs = [
+    {
+      name: "naming/queries",
+      files: featuresGlob(featureRoot, "**/queries/*.ts"),
+      ignores: featuresGlob(featureRoot, "shared/queries/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": prefixPattern },
+        ],
+      },
+    },
+    {
+      name: "naming/queries-shared",
+      files: featuresGlob(featureRoot, "shared/queries/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "naming/queries-export",
+      files: featuresGlob(featureRoot, "**/queries/*.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/queries-export": "error",
+      },
+    },
+    {
+      name: "naming/supabase-select",
+      files: featuresGlob(featureRoot, "**/queries/*.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/supabase-select-typed-columns": "error",
+      },
+    },
+    {
+      name: "layers/queries",
+      files: [`${featureRoot}/**/queries/*.ts`],
+      rules: {
+        "no-restricted-syntax": [
+          "error",
+          {
+            selector: "TryStatement",
+            message:
+              "try-catch is not allowed in queries. Error handling belongs in entries.",
+          },
+          {
+            selector: "IfStatement",
+            message:
+              "if statements are not allowed in queries. Conditional logic belongs in services.",
+          },
+          {
+            selector: "ForStatement",
+            message:
+              "Loops are not allowed in queries. Queries should be thin CRUD wrappers — iteration belongs in services.",
+          },
+          {
+            selector: "ForOfStatement",
+            message:
+              "Loops are not allowed in queries. Queries should be thin CRUD wrappers — iteration belongs in services.",
+          },
+          {
+            selector: "ForInStatement",
+            message:
+              "Loops are not allowed in queries. Queries should be thin CRUD wrappers — iteration belongs in services.",
+          },
+          {
+            selector: "WhileStatement",
+            message:
+              "Loops are not allowed in queries. Queries should be thin CRUD wrappers — iteration belongs in services.",
+          },
+          {
+            selector: "DoWhileStatement",
+            message:
+              "Loops are not allowed in queries. Queries should be thin CRUD wrappers — iteration belongs in services.",
+          },
+          {
+            selector: "ThrowStatement",
+            message:
+              "throw is not allowed in queries. Queries must return Supabase's { data, error } shape as-is. Error handling belongs in entries.",
+          },
+          { selector: loggerSelector, message: loggerMessage },
+          {
+            selector: aliasDynamicImportSelector,
+            message: aliasDynamicImportMessage,
+          },
+        ],
+      },
+    },
+    {
+      name: "imports/queries",
+      files: [`${featureRoot}/**/queries/*.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          { patterns: [...LAYER_PATTERNS, ...LATERAL_PATTERNS, ...MAPPING_PATTERNS] },
+        ],
+      },
+    },
+  ];
+
+  for (const prefix of prefixes) {
+    const patterns = prefixLibPatterns(prefix, prefixLibMapping);
+    if (patterns.length === 0) continue;
+    configs.push({
+      name: `imports/queries/${prefix}`,
+      files: [`${featureRoot}/**/queries/${prefix}.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          {
+            patterns: [
+              ...LAYER_PATTERNS,
+              ...LATERAL_PATTERNS,
+              ...patterns,
+              ...MAPPING_PATTERNS,
+            ],
+          },
+        ],
+      },
+    });
+  }
+
+  return configs;
+}

package/src/common/layers/schemas.mjs

@@ -0,0 +1,45 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+import { localPlugin } from "../local-plugins/index.mjs";
+
+export function createSchemasConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  return [
+    {
+      name: "naming/schemas",
+      files: featuresGlob(featureRoot, "*/schemas/*.ts"),
+      ignores: featuresGlob(featureRoot, "shared/schemas/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*/schemas/*.ts": "<1>" },
+        ],
+      },
+    },
+    {
+      name: "naming/schemas-shared",
+      files: featuresGlob(featureRoot, "shared/schemas/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "naming/schema-naming",
+      files: featuresGlob(featureRoot, "**/schemas/*.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/schema-naming": "error",
+      },
+    },
+  ];
+}

package/src/common/layers/services.mjs

@@ -0,0 +1,115 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import { LIB_BOUNDARY_PATTERNS } from "../_internal/import-patterns.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+import {
+  aliasDynamicImportMessage,
+  aliasDynamicImportSelector,
+  loggerMessage,
+  loggerSelector,
+} from "../_internal/selectors.mjs";
+
+const LAYER_PATTERNS = [
+  {
+    group: ["**/entries/*", "**/entries"],
+    message: "services cannot import entries (layer violation)",
+  },
+  {
+    group: ["**/hooks/*", "**/hooks"],
+    message: "services cannot import hooks (layer violation)",
+  },
+];
+
+const LATERAL_PATTERNS = [
+  {
+    group: ["@/features/*/services/*", "@/features/*/services"],
+    message:
+      "services cannot import other feature's services (lateral violation)",
+  },
+];
+
+export function createServicesConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const prefixPattern = hasPrefixes ? `@(${prefixes.join("|")})` : "*";
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  return [
+    {
+      name: "naming/services",
+      files: featuresGlob(featureRoot, "**/services/*.ts"),
+      ignores: featuresGlob(featureRoot, "shared/services/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": prefixPattern },
+        ],
+      },
+    },
+    {
+      name: "naming/services-shared",
+      files: featuresGlob(featureRoot, "shared/services/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "layers/services",
+      files: [`${featureRoot}/**/services/*.ts`],
+      rules: {
+        "no-restricted-syntax": [
+          "error",
+          {
+            selector: "TryStatement",
+            message:
+              "try-catch is not allowed in services. Error handling belongs in entries.",
+          },
+          {
+            selector: "ThrowStatement",
+            message:
+              "throw is not allowed in services. Communicate failures via T | null / { data, error } / empty default. Native exceptions from libs auto-propagate to entry's catch.",
+          },
+          { selector: loggerSelector, message: loggerMessage },
+          {
+            selector:
+              "LogicalExpression[operator='??'][left.type='ChainExpression'][left.expression.property.name='message'][right.type='Literal']",
+            message:
+              "Dead fallback for error message. If you reached this branch the error is known — return the error directly. Unhandled exceptions belong in entries.",
+          },
+          {
+            selector:
+              "LogicalExpression[operator='??'][left.type='MemberExpression'][left.property.name='error'][right.type='ObjectExpression']",
+            message:
+              "Dead fallback for nullable error. Check `if (error)` and return the error directly. Unhandled exceptions belong in entries.",
+          },
+          {
+            selector: aliasDynamicImportSelector,
+            message: aliasDynamicImportMessage,
+          },
+        ],
+      },
+    },
+    {
+      name: "imports/services",
+      files: [`${featureRoot}/**/services/*.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          {
+            patterns: [
+              ...LAYER_PATTERNS,
+              ...LATERAL_PATTERNS,
+              ...LIB_BOUNDARY_PATTERNS,
+            ],
+          },
+        ],
+      },
+    },
+  ];
+}

package/src/common/layers/top-level-utils.mjs

@@ -0,0 +1,18 @@
+import { checkFile } from "../_internal/plugins.mjs";
+
+export function createTopLevelUtilsConfigs({ featureRoot }) {
+  const utilsRoot = featureRoot.replace(/features$/, "utils");
+  return [
+    {
+      name: "naming/top-level-utils",
+      files: [`${utilsRoot}/**/*.ts`],
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": "*" },
+        ],
+      },
+    },
+  ];
+}

package/src/common/layers/types.mjs

@@ -0,0 +1,44 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import { MAPPING_PATTERNS } from "../_internal/import-patterns.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+
+export function createTypesConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  return [
+    {
+      name: "naming/types",
+      files: featuresGlob(featureRoot, "*/types/*.ts"),
+      ignores: featuresGlob(featureRoot, "shared/types/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*/types/*.ts": "<1>" },
+        ],
+      },
+    },
+    {
+      name: "naming/types-shared",
+      files: featuresGlob(featureRoot, "shared/types/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "imports/feature-types",
+      files: [`${featureRoot}/**/types/*.ts`],
+      rules: {
+        "no-restricted-imports": ["error", { patterns: MAPPING_PATTERNS }],
+      },
+    },
+  ];
+}

package/src/common/layers/utils.mjs

@@ -0,0 +1,50 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import {
+  LIB_BOUNDARY_PATTERNS,
+  MAPPING_PATTERNS,
+} from "../_internal/import-patterns.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+
+export function createUtilsConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  return [
+    {
+      name: "naming/utils",
+      files: featuresGlob(featureRoot, "*/utils/*.ts"),
+      ignores: featuresGlob(featureRoot, "shared/utils/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*/utils/*.ts": "<1>" },
+        ],
+      },
+    },
+    {
+      name: "naming/utils-shared",
+      files: featuresGlob(featureRoot, "shared/utils/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "imports/utils",
+      files: [`${featureRoot}/**/utils/*.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          { patterns: [...LIB_BOUNDARY_PATTERNS, ...MAPPING_PATTERNS] },
+        ],
+      },
+    },
+  ];
+}

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

@@ -1,33 +1,3 @@
-/**
- * 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) {