@yasainet/eslint 0.0.48 → 0.0.50

package/package.json

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

package/src/common/layers.mjs

@@ -1,3 +1,5 @@
+import { localPlugin } from "./local-plugins/index.mjs";
+
 /** Scope layer rules to the given feature root. */
 export function createLayersConfigs(featureRoot) {
   const loggerSelector = "CallExpression[callee.object.name='logger']";
@@ -69,6 +71,20 @@ export function createLayersConfigs(featureRoot) {
         ],
       },
     },
+    // Boundary type safety: repositories & services must not leak `any`
+    // into their public API. Uses type-aware inspection of the inferred
+    // return type so unannotated functions are still checked.
+    {
+      name: "layers/no-any-return",
+      files: [
+        `${featureRoot}/**/repositories/*.ts`,
+        `${featureRoot}/**/services/*.ts`,
+      ],
+      plugins: { local: localPlugin },
+      rules: {
+        "local/no-any-return": "error",
+      },
+    },
     // Services: try-catch + logger + dead error fallbacks
     {
       name: "layers/services",

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

@@ -2,6 +2,7 @@ import { actionHandleServiceRule } from "./action-handle-service.mjs";
 import { featureNameRule } from "./feature-name.mjs";
 import { importPathStyleRule } from "./import-path-style.mjs";
 import { namespaceImportNameRule } from "./namespace-import-name.mjs";
+import { noAnyReturnRule } from "./no-any-return.mjs";
 import { schemaNamingRule } from "./schema-naming.mjs";
 
 /** Single plugin object to avoid ESLint "Cannot redefine plugin" errors. */
@@ -11,6 +12,7 @@ export const localPlugin = {
     "feature-name": featureNameRule,
     "import-path-style": importPathStyleRule,
     "namespace-import-name": namespaceImportNameRule,
+    "no-any-return": noAnyReturnRule,
     "schema-naming": schemaNamingRule,
   },
 };

package/src/common/local-plugins/no-any-return.mjs

@@ -0,0 +1,100 @@
+import ts from "typescript";
+
+/**
+ * Exported function の return type が any を含んでいる場合に error:
+ *
+ * - typescript-eslint の type checker を使って inferred type まで見る
+ * - repositories / services の API 境界を any 汚染から守ることで、domain shape が型で保証される
+ * - Promise<any>, Promise<{ data: any }>, Array<any> など nested も展開して検査する
+ */
+export const noAnyReturnRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Disallow exported functions whose inferred return type contains `any`.",
+    },
+    messages: {
+      anyInReturn:
+        "Exported function's inferred return type contains `any`: {{ typeText }}. Annotate with a known type or narrow from the source — public layer APIs must have known shapes.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const services = context.sourceCode.parserServices;
+    if (!services?.program || !services.esTreeNodeToTSNodeMap) return {};
+    const checker = services.program.getTypeChecker();
+
+    const isExported = (node) => {
+      const parent = node.parent;
+      if (!parent) return false;
+      if (parent.type === "ExportNamedDeclaration") return true;
+      if (parent.type === "ExportDefaultDeclaration") return true;
+      return false;
+    };
+
+    const getReturnType = (node) => {
+      const tsNode = services.esTreeNodeToTSNodeMap.get(node);
+      if (!tsNode) return null;
+      const signature = checker.getSignatureFromDeclaration(tsNode);
+      if (!signature) return null;
+      return checker.getReturnTypeOfSignature(signature);
+    };
+
+    // `any` を type tree 全体で検出する (Promise<any>, { a: any }, any[] 等を展開)
+    const containsAny = (type, seen = new Set()) => {
+      if (!type) return false;
+      if (seen.has(type)) return false;
+      seen.add(type);
+
+      if (type.flags & ts.TypeFlags.Any) return true;
+
+      if (type.isUnion?.() || type.isIntersection?.()) {
+        return type.types.some((t) => containsAny(t, seen));
+      }
+
+      const typeArgs =
+        checker.getTypeArguments?.(type) ??
+        type.typeArguments ??
+        type.aliasTypeArguments ??
+        [];
+      for (const arg of typeArgs) {
+        if (containsAny(arg, seen)) return true;
+      }
+
+      const props = type.getProperties?.() ?? [];
+      for (const prop of props) {
+        const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+        if (!decl) continue;
+        const propType = checker.getTypeOfSymbolAtLocation(prop, decl);
+        if (containsAny(propType, seen)) return true;
+      }
+
+      return false;
+    };
+
+    const check = (node) => {
+      if (!isExported(node)) return;
+      const returnType = getReturnType(node);
+      if (!returnType) return;
+      if (!containsAny(returnType)) return;
+
+      const typeText = checker.typeToString(
+        returnType,
+        undefined,
+        ts.TypeFormatFlags.NoTruncation,
+      );
+      context.report({
+        node: node.id ?? node,
+        messageId: "anyInReturn",
+        data: { typeText },
+      });
+    };
+
+    return {
+      FunctionDeclaration: check,
+      FunctionExpression: check,
+      ArrowFunctionExpression: check,
+    };
+  },
+};

package/src/common/rules.mjs

@@ -91,6 +91,19 @@ export const rulesConfigs = [
       // on a non-null column). Kept at warn until existing violations are
       // cleaned up across consuming projects; promote to error afterwards.
       "@typescript-eslint/no-unnecessary-condition": "warn",
+      // Type-aware async safety: silent await omissions are a leading cause
+      // of race conditions in server actions and background tasks.
+      "@typescript-eslint/no-floating-promises": "error",
+      "@typescript-eslint/no-misused-promises": "error",
+      "@typescript-eslint/await-thenable": "error",
+      "@typescript-eslint/require-await": "error",
+      // Type-aware `any` propagation checks: any が境界を越えた瞬間に
+      // 残りのコードで型検査が無効化されるため、検出したら確実に止める。
+      "@typescript-eslint/no-unsafe-assignment": "error",
+      "@typescript-eslint/no-unsafe-call": "error",
+      "@typescript-eslint/no-unsafe-member-access": "error",
+      "@typescript-eslint/no-unsafe-argument": "error",
+      "@typescript-eslint/no-unsafe-return": "error",
     },
   },
 ];