@yasainet/eslint 0.0.57 → 0.0.59

package/README.md

@@ -20,24 +20,45 @@ src/
 └── deno/     # Deno entry point (entry-point boundary, _utils boundary, _lib boundary)
 ```
 
-Each entry point enforces a feature-based architecture with the following convention in consuming projects:
+Each entry point enforces a feature-based architecture. **Files do not carry role suffixes — the directory declares the role**:
 
 ```text
 {featureRoot}/
 ├── {feature}/
-│   ├── interactors/    # *.interactor.ts — entry points
-│   ├── services/       # *.service.ts — business logic
-│   ├── queries/        # *.query.ts — data access
-│   ├── types/          # *.type.ts
-│   ├── schemas/        # *.schema.ts
-│   ├── utils/          # *.util.ts
-│   └── constants/      # *.constant.ts
+│   ├── interactors/    # entry points (server.ts / admin.ts / client.ts)
+│   ├── services/       # business logic (server.ts ...)
+│   ├── queries/        # data access (one file per upstream lib: <lib-name>.ts)
+│   ├── types/          # type defs (one file per feature: <feature>.ts)
+│   ├── schemas/        # zod schemas (<feature>.ts)
+│   ├── utils/          # pure helpers (<feature>.ts)
+│   └── constants/      # constants (<feature>.ts)
 ├── shared/             # Cross-feature shared modules
-├── ...
-{libRoot}/              # *.lib.ts — library wrappers (e.g., supabase.lib.ts)
-{utilsRoot}/            # *.util.ts — top-level utilities (e.g., font.util.ts)
+{libRoot}/
+├── {single-client-lib}/index.ts   # SDK wrapper entry (e.g., gallery-dl, fxembed, r2)
+├── {single-client-lib}/types.ts   # raw SDK types
+├── {single-client-lib}/<sub>.ts   # internal sub-modules (parser, etc.) — auto-hidden from queries
+├── {multi-client-lib}/<role>.ts   # one role per file (e.g., supabase: admin / server / client / proxy)
+└── {multi-client-lib}/types.ts
+{utilsRoot}/            # top-level pure utilities (cn.ts / logger.ts ...)
 ```
 
+### single-client vs multi-client lib
+
+| Detected by                                  | Treated as       | Example                                       |
+| -------------------------------------------- | ---------------- | --------------------------------------------- |
+| `lib/<dir>/index.ts` exists                  | single-client    | `lib/gallery-dl/{index.ts, parser.ts, types.ts}` |
+| `lib/<dir>/index.ts` absent                  | multi-client     | `lib/supabase/{admin.ts, server.ts, client.ts, ...}` |
+
+For single-client libs the prefix mapping registers only the directory name, automatically hiding internal sub-modules (e.g., `parser.ts`) from the queries layer. For multi-client libs every plain `<role>.ts` is registered.
+
+### File naming rules
+
+- **No multi-extension suffixes** (`.lib`, `.service`, `.query`, `.util`, `.type`, `.schema`, `.constant`, `.interactor` are forbidden). The directory carries the role.
+- `lib/<dir>/index.ts` for single-client lib entries (avoids `lib/<dir>/<dir>.ts` redundancy).
+- `lib/<dir>/types.ts` and `lib/<dir>/proxy.ts` are excluded from the prefix mapping so queries cannot directly depend on them.
+- `<feature>/{types,schemas,utils,constants}/<feature>.ts` — exactly one file per feature, named after the feature.
+- `<feature>/queries/<lib-name>.ts` — file name must match a registered lib prefix; queries can only import from the matching lib (lib-boundary lint).
+
 ## Setup
 
 ### Next.js + Node.js + Deno

package/package.json

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

package/src/common/constants.mjs

@@ -20,14 +20,22 @@ function findProjectRoot() {
 
 const PROJECT_ROOT = findProjectRoot();
 
-const EXCLUDE_LIST = ["proxy.lib.ts"];
+/**
+ * Files / basenames that should never become a prefix:
+ *
+ * - `types.ts`: 型定義のみで lib の役割を持たない
+ * - `proxy.ts`: middleware adapter (Next.js の proxy.ts と意味が衝突するため queries から呼ばせない)
+ */
+const EXCLUDE_LIST = ["types.ts", "proxy.ts"];
 
-/** Extract the base name from a .ts filename by stripping all extensions. */
-function baseName(filename) {
-  return filename.replace(/\..*$/, "");
-}
-
-/** Scan lib directory derived from featureRoot and build prefix-to-lib-relative-path mapping. */
+/**
+ * Scan lib directory and build prefix-to-lib-relative-path mapping:
+ *
+ * - single-client lib (`lib/<dir>/index.ts`): prefix = dir 名、entry のみ登録 — 同 dir 内の他ファイル (parser 等 sub-module) は自動除外
+ * - multi-client lib (index.ts なし): dir 内の全 `<role>.ts` を登録 (e.g., supabase の admin / server / client)
+ * - 多重拡張子 (`.test.ts` 等) を持つファイルは sub-module / 非 lib として除外
+ * - types.ts / proxy.ts のような lib として queries から呼ばせたくないものは EXCLUDE_LIST で除外
+ */
 export function generatePrefixLibMapping(featureRoot) {
   const libRoot = featureRoot.replace(/features$/, "lib");
   const libDir = path.join(PROJECT_ROOT, libRoot);
@@ -37,30 +45,35 @@ export function generatePrefixLibMapping(featureRoot) {
     return mapping;
   }
 
+  const isPlainTsFile = (name) =>
+    name.endsWith(".ts") &&
+    name.split(".").length === 2 &&
+    !EXCLUDE_LIST.includes(name);
+
   const entries = fs.readdirSync(libDir, { withFileTypes: true });
 
   for (const entry of entries) {
-    if (EXCLUDE_LIST.includes(entry.name)) {
-      continue;
-    }
-
     if (entry.isDirectory()) {
       const subDir = path.join(libDir, entry.name);
       const subEntries = fs.readdirSync(subDir, { withFileTypes: true });
+      const plainTsFiles = subEntries
+        .filter((e) => e.isFile() && isPlainTsFile(e.name))
+        .map((e) => e.name);
 
-      for (const subEntry of subEntries) {
-        if (
-          subEntry.isFile() &&
-          subEntry.name.endsWith(".lib.ts") &&
-          !EXCLUDE_LIST.includes(subEntry.name)
-        ) {
-          const prefix = baseName(subEntry.name);
-          mapping[prefix] = `${entry.name}/${subEntry.name.replace(".lib.ts", "")}`;
+      if (plainTsFiles.includes("index.ts")) {
+        // single-client lib: index.ts を entry とみなし、prefix = dir 名で登録
+        // 同 dir 内の他ファイル (parser 等) は sub-module として自動除外
+        mapping[entry.name] = `${entry.name}/index`;
+      } else {
+        // multi-client lib: 全 role file を登録 (e.g., supabase の admin / server / client)
+        for (const fileName of plainTsFiles) {
+          const prefix = fileName.replace(/\.ts$/, "");
+          mapping[prefix] = `${entry.name}/${prefix}`;
         }
       }
-    } else if (entry.isFile() && entry.name.endsWith(".lib.ts")) {
-      const prefix = baseName(entry.name);
-      mapping[prefix] = entry.name.replace(".lib.ts", "");
+    } else if (entry.isFile() && isPlainTsFile(entry.name)) {
+      const prefix = entry.name.replace(/\.ts$/, "");
+      mapping[prefix] = prefix;
     }
   }
 

package/src/common/imports.mjs

@@ -62,23 +62,23 @@ const LATERAL_PATTERNS = {
 const CARDINALITY_PATTERNS = {
   server: [
     {
-      group: ["**/services/client.service*", "**/services/admin.service*"],
+      group: ["**/services/client", "**/services/admin"],
       message:
-        "server.interactor can only import server.service (cardinality violation)",
+        "server interactor can only import server service (cardinality violation)",
     },
   ],
   client: [
     {
-      group: ["**/services/server.service*", "**/services/admin.service*"],
+      group: ["**/services/server", "**/services/admin"],
       message:
-        "client.interactor can only import client.service (cardinality violation)",
+        "client interactor can only import client service (cardinality violation)",
     },
   ],
   admin: [
     {
-      group: ["**/services/server.service*", "**/services/client.service*"],
+      group: ["**/services/server", "**/services/client"],
       message:
-        "admin.interactor can only import admin.service (cardinality violation)",
+        "admin interactor can only import admin service (cardinality violation)",
     },
   ],
 };
@@ -90,7 +90,7 @@ function prefixLibPatterns(prefix, mapping) {
     .filter((p) => p !== prefix)
     .map((p) => ({
       group: [`**/lib/${mapping[p]}`, `**/lib/${mapping[p]}/*`],
-      message: `${prefix}.query.ts can only import from lib/${allowedLib}. Use the correct query file for this lib.`,
+      message: `queries/${prefix}.ts can only import from lib/${allowedLib}. Use the correct query file for this lib.`,
     }));
 }
 
@@ -329,7 +329,7 @@ export function createImportsConfigs(
     configs.push(
       makeConfig(
         `queries/${prefix}`,
-        [`${featureRoot}/**/queries/${prefix}.query.ts`],
+        [`${featureRoot}/**/queries/${prefix}.ts`],
         LAYER_PATTERNS.queries,
         LATERAL_PATTERNS.queries,
         patterns,
@@ -401,7 +401,7 @@ export function createImportsConfigs(
     configs.push(
       makeConfig(
         `interactors/${prefix}`,
-        [`${featureRoot}/**/interactors/${prefix}.interactor.ts`],
+        [`${featureRoot}/**/interactors/${prefix}.ts`],
         LAYER_PATTERNS.interactors,
         LATERAL_PATTERNS.interactors,
         CARDINALITY_PATTERNS[prefix],

package/src/common/local-plugins/feature-name.mjs

@@ -113,11 +113,11 @@ export const featureNameRule = {
     // generated types without duplicating the file.
     const computedTypePath = path.join(
       projectRoot,
-      featureRoot.replace(/features$/, "lib/supabase/supabase.type.ts"),
+      featureRoot.replace(/features$/, "lib/supabase/types.ts"),
     );
     const fallbackTypePath = path.join(
       projectRoot,
-      "src/lib/supabase/supabase.type.ts",
+      "src/lib/supabase/types.ts",
     );
     const supabaseTypePath = fs.existsSync(computedTypePath)
       ? computedTypePath

package/src/common/local-plugins/namespace-import-name.mjs

@@ -2,19 +2,21 @@
  * Enforce consistent naming for `import * as` namespace imports
  * within feature-based architecture.
  *
- * Convention: import * as {featureName}{Scope}{Layer} from "{path}/{scope}.{layerExt}"
+ * Convention: import * as {featureName}{Scope}{Layer} from "{path}/{layerDir}/{scope}"
+ *
+ * Layer はファイル名 suffix ではなくディレクトリ名 (`queries/` / `services/` 等) から識別する。
  */
 
 /** @type {Record<string, string>} */
-const LAYER_MAP = {
-  query: "Query",
-  service: "Service",
-  domain: "Domain",
-  interactor: "Interactor",
-  util: "Util",
-  type: "Type",
-  schema: "Schema",
-  constant: "Constant",
+const LAYER_DIR_MAP = {
+  queries: "Query",
+  services: "Service",
+  domains: "Domain",
+  interactors: "Interactor",
+  utils: "Util",
+  types: "Type",
+  schemas: "Schema",
+  constants: "Constant",
 };
 
 /** Convert a snake_case or kebab-case string to camelCase. */
@@ -29,8 +31,11 @@ function toPascalCase(str) {
 }
 
 /**
- * Parse import source to extract featureName, scope, and layer.
- * Returns null if the source doesn't match the expected pattern.
+ * Parse import source to extract featureName, scope, and layer:
+ *
+ * - feature root 内の path のみを対象とする (外部 lib / shared / 相対インポートで feature 外に行くものは無視)
+ * - segments は `[feature, layerDir, ..., file]` の形式を想定し、末尾要素を scope として取り出す
+ * - layerDir が LAYER_DIR_MAP に無い場合は対象外
  */
 function parseImportSource(importPath, featureRoot) {
   // Normalize alias: @/features/... → features/...
@@ -46,20 +51,15 @@ function parseImportSource(importPath, featureRoot) {
   if (rootIdx === -1) return null;
 
   const afterRoot = normalized.slice(rootIdx + rootPrefix.length);
-  // Expected: {feature}/{layerDir}/{scope}.{layerExt}
+  // Expected: {feature}/{layerDir}/{scope}
   const segments = afterRoot.split("/");
-  if (segments.length < 2) return null;
+  if (segments.length < 3) return null;
 
   const featureDir = segments[0];
-  const fileName = segments[segments.length - 1].replace(/\.[jt]sx?$/, "");
-
-  const dotIdx = fileName.indexOf(".");
-  if (dotIdx === -1) return null;
-
-  const scope = fileName.slice(0, dotIdx);
-  const ext = fileName.slice(dotIdx + 1);
+  const layerDir = segments[1];
+  const scope = segments[segments.length - 1].replace(/\.[jt]sx?$/, "");
 
-  const layer = LAYER_MAP[ext];
+  const layer = LAYER_DIR_MAP[layerDir];
   if (!layer) return null;
 
   return { featureDir, scope, layer };

package/src/common/local-plugins/queries-export.mjs

@@ -1,9 +1,9 @@
 /**
- * Enforce verb allow list for `queries/*.query.ts` exports.
+ * Enforce verb allow list for `queries/*.ts` exports:
  *
- * The queries layer is the TS-idiomatic translation of Rails 5 actions
- * (index/show -> get, create, update, destroy -> delete). Auth ceremonies
- * (signUp / signIn / signOut) are admitted as industry-standard exceptions.
+ * - The queries layer is the TS-idiomatic translation of Rails 5 actions
+ *   (index/show -> get, create, update, destroy -> delete)
+ * - Auth ceremonies (signUp / signIn / signOut) are admitted as industry-standard exceptions
  */
 
 const QUERIES_ALLOW = /^(get|create|update|delete|signUp|signIn|signOut)([A-Z]|$)/;

package/src/common/local-plugins/queries-namespace-import.mjs

@@ -1,13 +1,14 @@
 /**
- * Enforce namespace imports for `queries/*.query.ts` files.
+ * Enforce namespace imports for files under `queries/`:
  *
- * Value imports must use `import * as xxxQuery from "..."` so that the
- * `naming/namespace-import-name` rule can guarantee a single canonical
- * binding (e.g. `comicsServerQuery.getComics`). Type-only imports are
- * exempted because they have no runtime presence.
+ * - Value imports must use `import * as xxxQuery from "..."` so that the
+ *   `naming/namespace-import-name` rule can guarantee a single canonical
+ *   binding (e.g. `comicsServerQuery.getComics`)
+ * - Type-only imports are exempted because they have no runtime presence
+ * - 検出は path に `/queries/<name>` が含まれることのみで行い、suffix には依存しない
  */
 
-const QUERIES_PATH = /\/queries\/[^/]+\.query$/;
+const QUERIES_PATH = /\/queries\/[^/]+$/;
 
 export const queriesNamespaceImportRule = {
   meta: {

package/src/common/local-plugins/supabase-columns-satisfies.mjs

@@ -1,50 +1,47 @@
 /**
- * Enforce `[...] as const satisfies readonly (keyof Tables<"...">)[]` for
- * `*_COLUMNS` constant declarations.
+ * Enforce `<string literal> as const` for `*_COLUMNS` constant declarations.
  *
- * Apply to `**\/queries/*.query.ts`. Without `as const satisfies`, typos
- * in column names slip past the lint phase — Supabase only complains at
- * runtime when the query executes. The `satisfies` annotation forces
- * TypeScript to validate every entry against the schema before the code
- * ever runs. The actual `keyof Tables<"...">` content is left to the type
- * checker; the lint rule only verifies the syntactic shape.
+ * Apply to `**\/queries/*.ts` and `**\/constants/*.ts`.
+ *
+ * `*_COLUMNS` 定数は Supabase の `.select()` に直接渡される。`as const` を
+ * 外すと TypeScript が `string` に widen し、Supabase の `.select<Query>()`
+ * が literal を parse できなくなって row 型推論が壊れる（戻り値が
+ * `GenericStringError` になる）。
+ *
+ * Allowed:
+ *   const POST_DETAIL_COLUMNS = "id,url,platform" as const;
+ *
+ * Banned:
+ *   const POST_DETAIL_COLUMNS = "id,url,platform";              // string に widen
+ *   const POST_DETAIL_COLUMNS = ["id", "url"] as const;         // 配列
+ *   const POST_DETAIL_COLUMNS = [...] as const satisfies ...;   // 配列 + satisfies
+ *   const POST_DETAIL_COLUMNS = `id,${col}`;                    // template literal
+ *
+ * Why: シンプルな string literal を `as const` で保つだけで、Supabase の
+ * 型推論（row 型 / column 名タイポ検出）はすべて自動で効く。runtime helper
+ * （`joinColumns` 等）は不要。
  */
 
 const COLUMNS_NAME = /^[A-Z][A-Z0-9_]*_COLUMNS$/;
 
-/** Unwrap nested type assertions and find the underlying expression. */
-function unwrapTypeAssertions(node) {
-  let current = node;
-  while (
-    current &&
-    (current.type === "TSAsExpression" ||
-      current.type === "TSSatisfiesExpression")
-  ) {
-    current = current.expression;
-  }
-  return current;
-}
-
-function isAsConstSatisfies(initNode) {
+function isStringAsConst(initNode) {
   if (!initNode) return false;
-  if (initNode.type !== "TSSatisfiesExpression") return false;
-  const inner = initNode.expression;
-  if (inner.type !== "TSAsExpression") return false;
-  const ann = inner.typeAnnotation;
-  if (!ann) return false;
-  if (ann.type !== "TSTypeReference") return false;
+  if (initNode.type !== "TSAsExpression") return false;
+  const ann = initNode.typeAnnotation;
+  if (!ann || ann.type !== "TSTypeReference") return false;
   if (ann.typeName.type !== "Identifier") return false;
   if (ann.typeName.name !== "const") return false;
-  if (inner.expression.type !== "ArrayExpression") return false;
-  return true;
+  const inner = initNode.expression;
+  if (inner.type !== "Literal") return false;
+  return typeof inner.value === "string";
 }
 
 export const supabaseColumnsSatisfiesRule = {
   meta: {
     type: "problem",
     messages: {
-      missing:
-        'Column constant `{{ name }}` must use `[...] as const satisfies readonly (keyof Tables<"table">)[]` so column names are validated against the schema at compile time.',
+      shape:
+        'Column constant `{{ name }}` must be `"<comma-separated columns>" as const`. `as const` を外すと Supabase の `.select()` 型推論が壊れる。配列 / template literal も不可。',
     },
     schema: [],
   },
@@ -53,15 +50,11 @@ export const supabaseColumnsSatisfiesRule = {
       VariableDeclarator(node) {
         if (node.id.type !== "Identifier") return;
         if (!COLUMNS_NAME.test(node.id.name)) return;
-        // Only enforce on array initializers. String literals like
-        // POST_UPSERT_CONFLICT_COLUMNS are PostgREST conflict-target specs,
-        // not column lists, and are out of scope.
-        const inner = unwrapTypeAssertions(node.init);
-        if (!inner || inner.type !== "ArrayExpression") return;
-        if (isAsConstSatisfies(node.init)) return;
+        if (!node.init) return;
+        if (isStringAsConst(node.init)) return;
         context.report({
           node: node.id,
-          messageId: "missing",
+          messageId: "shape",
           data: { name: node.id.name },
         });
       },

package/src/common/local-plugins/supabase-select-typed-columns.mjs

@@ -1,59 +1,51 @@
 /**
- * Enforce typed column constants for Supabase `.select()` calls.
+ * Enforce explicit column lists for Supabase `.select()` calls.
  *
- * Apply to `**\/queries/*.query.ts`. Forces `.select()` to take the form
- * `joinColumns(<X_COLUMNS>)` where `X_COLUMNS` is an UPPER_SNAKE identifier
- * ending with `_COLUMNS`. The identifier is expected to be declared with
- * `as const satisfies readonly (keyof Tables<"table">)[]` so the column
- * names are validated against the schema at compile time. The `satisfies`
- * shape itself is enforced by the companion `supabase-columns-satisfies`
- * rule.
+ * Apply to `**\/queries/*.ts`. `.select()` の引数は次のいずれかでなければならない:
  *
- * `joinColumns()` is a project-supplied helper that comma-joins a const
- * string tuple while preserving the literal string type so Supabase's
- * `.select()` type parser can infer the row shape (a plain `.join(",")`
- * widens to `string` and breaks inference).
+ * - inline string literal（例: `.select("id,url,platform")`）
+ * - `*_COLUMNS` という UPPER_SNAKE 命名の identifier（例: `.select(POST_DETAIL_COLUMNS)`）
+ *
+ * `*_COLUMNS` 定数は companion rule `supabase-columns-satisfies` で
+ * `<string literal> as const` の形が強制される。これにより:
+ *
+ * - Supabase の `.select()` は literal string を parse して row 型を推論できる
+ * - 存在しない column 名は Supabase の型推論が `SelectQueryError` として弾く（compile time）
+ * - runtime helper（`joinColumns`）は不要
  *
  * Banned:
- *   .select()                                implicit "all columns"
- *   .select("*")                             silent exposure of new schema columns
- *   .select("id, name")                      inline literal, invisible to grep
- *   .select(`${x}, y`)                       dynamic concatenation
- *   .select(POST_LIST_COLUMNS.join(","))     plain .join widens to `string`, breaks inference
- *   .select(someVar)                         non-conforming variable
+ *   .select()                    implicit "all columns"
+ *   .select("*")                 silent exposure of new schema columns
+ *   .select(`${x},y`)            dynamic concatenation
+ *   .select(cols.join(","))      runtime expression
+ *   .select(someVar)             non-conforming variable
  *
  * Allowed:
- *   .select(joinColumns(POST_LIST_COLUMNS))  typed constant via project helper
+ *   .select("id,url,platform")        inline literal
+ *   .select(POST_DETAIL_COLUMNS)      *_COLUMNS named constant
  *
- * Why: column lists must be (1) named for grep / review, (2) checked
- * against the schema, (3) never silently grow on schema additions.
- * For column-level access control, use Postgres views (`from("posts_public")`).
+ * Why: column lists must be (1) statically analyzable for grep / review,
+ * (2) literal so Supabase can infer the row shape, (3) never silently grow
+ * on schema additions. For column-level access control, use Postgres views
+ * (`from("posts_public")`).
  */
 
 const COLUMNS_NAME = /^[A-Z][A-Z0-9_]*_COLUMNS$/;
 
-function asJoinColumnsCall(arg) {
-  if (!arg) return null;
-  if (arg.type !== "CallExpression") return null;
-  if (arg.callee.type !== "Identifier") return null;
-  if (arg.callee.name !== "joinColumns") return null;
-  if (arg.arguments.length !== 1) return null;
-  if (arg.arguments[0].type !== "Identifier") return null;
-  return arg.arguments[0];
-}
-
 export const supabaseSelectTypedColumnsRule = {
   meta: {
     type: "problem",
     messages: {
       noArgs:
-        "Empty `.select()` returns all columns implicitly. Pass `joinColumns(<X_COLUMNS>)` where X_COLUMNS is a typed constant.",
-      literalArg:
-        'Inline `.select()` argument is forbidden. Define `const X_COLUMNS = [...] as const satisfies readonly (keyof Tables<"table">)[];` and call `.select(joinColumns(X_COLUMNS))`. Use Postgres views for column-level access control.',
+        "Empty `.select()` returns all columns implicitly. Pass a string literal or a `*_COLUMNS` constant.",
+      wildcard:
+        '`.select("*")` exposes new schema columns silently. Enumerate columns explicitly.',
+      template:
+        "Template literal in `.select()` defeats type inference. Use a string literal or a `*_COLUMNS` constant.",
       shapeArg:
-        '`.select()` argument must be `joinColumns(<X_COLUMNS>)`. Other expressions defeat type inference and column-level review.',
+        "`.select()` argument must be a string literal or a `*_COLUMNS` identifier.",
       naming:
-        "Column constant `{{ name }}` must be UPPER_SNAKE_CASE ending with `_COLUMNS` (e.g. POST_LIST_COLUMNS, POST_DETAIL_COLUMNS).",
+        "Column constant `{{ name }}` must be UPPER_SNAKE_CASE ending with `_COLUMNS` (e.g. POST_DETAIL_COLUMNS).",
     },
     schema: [],
   },
@@ -71,24 +63,34 @@ export const supabaseSelectTypedColumnsRule = {
 
         const arg = node.arguments[0];
 
-        if (arg.type === "Literal" || arg.type === "TemplateLiteral") {
-          context.report({ node: arg, messageId: "literalArg" });
+        if (arg.type === "Literal") {
+          if (typeof arg.value !== "string") {
+            context.report({ node: arg, messageId: "shapeArg" });
+            return;
+          }
+          if (arg.value.trim() === "*") {
+            context.report({ node: arg, messageId: "wildcard" });
+          }
           return;
         }
 
-        const id = asJoinColumnsCall(arg);
-        if (!id) {
-          context.report({ node: arg, messageId: "shapeArg" });
+        if (arg.type === "TemplateLiteral") {
+          context.report({ node: arg, messageId: "template" });
           return;
         }
 
-        if (!COLUMNS_NAME.test(id.name)) {
-          context.report({
-            node: id,
-            messageId: "naming",
-            data: { name: id.name },
-          });
+        if (arg.type === "Identifier") {
+          if (!COLUMNS_NAME.test(arg.name)) {
+            context.report({
+              node: arg,
+              messageId: "naming",
+              data: { name: arg.name },
+            });
+          }
+          return;
         }
+
+        context.report({ node: arg, messageId: "shapeArg" });
       },
     };
   },

package/src/common/naming.mjs

@@ -2,61 +2,69 @@ import { featuresGlob } from "./constants.mjs";
 import { localPlugin } from "./local-plugins/index.mjs";
 import { checkFile } from "./plugins.mjs";
 
-/** Scope lib naming rules to the lib root derived from the given feature root. */
+/**
+ * Scope lib naming rules to the lib root derived from the given feature root:
+ *
+ * - basename は suffix なしの単一トークン (`*` パターン) を強制する
+ * - 多重拡張子 (`<name>.lib.ts` / `<name>.parser.ts` 等) は禁止 → 役割はディレクトリで宣言する
+ * - types.ts は対象外 (型のみで lib の役割を持たないため check 不要)
+ */
 export function createLibNamingConfigs(featureRoot) {
   const libRoot = featureRoot.replace(/features$/, "lib");
   return [
     {
       name: "naming/lib",
       files: [`${libRoot}/**/*.ts`],
-      ignores: [`${libRoot}/**/*.type.ts`],
       plugins: { "check-file": checkFile },
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": "*.lib" },
+          { "**/*.ts": "*" },
         ],
       },
     },
   ];
 }
 
-/** Scope utils naming rules to the utils root derived from the given feature root. */
+/**
+ * Scope utils naming rules to the utils root derived from the given feature root:
+ *
+ * - basename は suffix なしの単一トークン (`*` パターン) を強制する
+ * - 多重拡張子は禁止
+ */
 export function createUtilsNamingConfigs(featureRoot) {
   const utilsRoot = featureRoot.replace(/features$/, "utils");
   return [
     {
       name: "naming/top-level-utils",
       files: [`${utilsRoot}/**/*.ts`],
-      ignores: [`${utilsRoot}/**/*.type.ts`],
       plugins: { "check-file": checkFile },
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": "*.util" },
+          { "**/*.ts": "*" },
         ],
       },
     },
   ];
 }
 
-/** Scope naming rules to the given feature root. */
+/**
+ * Scope naming rules to the given feature root:
+ *
+ * - 全 layer (services / queries / interactors / utils / types / schemas / constants) で suffix を廃止
+ * - ファイル名 (basename) は単一トークン (`*` パターン) を強制し、role はディレクトリで宣言する
+ * - queries / services / interactors のファイル名は prefixLibMapping のキー (lib name) と一致させ、どの lib を呼ぶか明示する
+ * - shared/ 配下では feature 名でなく `shared` または lib name を allowed prefix として許可する
+ */
 export function createNamingConfigs(featureRoot, prefixLibMapping) {
   const prefixes = Object.keys(prefixLibMapping);
   const hasPrefixes = prefixes.length > 0;
-  const prefixPattern = hasPrefixes ? `@(${prefixes.join("|")})` : null;
+  const prefixPattern = hasPrefixes ? `@(${prefixes.join("|")})` : "*";
   const sharedPrefixPattern = hasPrefixes
     ? `@(shared|${prefixes.join("|")})`
     : "shared";
 
-  const servicePattern = prefixPattern
-    ? `${prefixPattern}.service`
-    : "*.service";
-  const queryPattern = prefixPattern ? `${prefixPattern}.query` : "*.query";
-  const interactorPattern = prefixPattern
-    ? `${prefixPattern}.interactor`
-    : "*.interactor";
-
   const configs = [];
 
   configs.push({
@@ -86,7 +94,7 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": servicePattern },
+          { "**/*.ts": prefixPattern },
         ],
       },
     },
@@ -98,13 +106,13 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": queryPattern },
+          { "**/*.ts": prefixPattern },
         ],
       },
     },
     {
       name: "naming/queries-export",
-      files: featuresGlob(featureRoot, "**/queries/*.query.ts"),
+      files: featuresGlob(featureRoot, "**/queries/*.ts"),
       plugins: { local: localPlugin },
       rules: {
         "local/queries-export": "error",
@@ -120,7 +128,7 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
     },
     {
       name: "naming/supabase-select",
-      files: featuresGlob(featureRoot, "**/queries/*.query.ts"),
+      files: featuresGlob(featureRoot, "**/queries/*.ts"),
       plugins: { local: localPlugin },
       rules: {
         "local/supabase-select-typed-columns": "error",
@@ -129,8 +137,8 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
     {
       name: "naming/supabase-columns-satisfies",
       files: [
-        ...featuresGlob(featureRoot, "**/queries/*.query.ts"),
-        ...featuresGlob(featureRoot, "**/constants/*.constant.ts"),
+        ...featuresGlob(featureRoot, "**/queries/*.ts"),
+        ...featuresGlob(featureRoot, "**/constants/*.ts"),
       ],
       plugins: { local: localPlugin },
       rules: {
@@ -155,7 +163,7 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${sharedPrefixPattern}.service` },
+          { "**/*.ts": sharedPrefixPattern },
         ],
       },
     },
@@ -166,7 +174,7 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${sharedPrefixPattern}.query` },
+          { "**/*.ts": sharedPrefixPattern },
         ],
       },
     },
@@ -175,14 +183,13 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
   configs.push(
     {
       name: "naming/types",
-      files: featuresGlob(featureRoot, "*/types/*.type.ts"),
+      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>" },
-          { ignoreMiddleExtensions: true },
         ],
       },
     },
@@ -193,26 +200,25 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${sharedPrefixPattern}.type` },
+          { "**/*.ts": sharedPrefixPattern },
         ],
       },
     },
     {
       name: "naming/schemas",
-      files: featuresGlob(featureRoot, "*/schemas/*.schema.ts"),
+      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>" },
-          { ignoreMiddleExtensions: true },
         ],
       },
     },
     {
       name: "naming/schema-naming",
-      files: featuresGlob(featureRoot, "**/schemas/*.schema.ts"),
+      files: featuresGlob(featureRoot, "**/schemas/*.ts"),
       plugins: { local: localPlugin },
       rules: {
         "local/schema-naming": "error",
@@ -225,20 +231,19 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${sharedPrefixPattern}.schema` },
+          { "**/*.ts": sharedPrefixPattern },
         ],
       },
     },
     {
       name: "naming/utils",
-      files: featuresGlob(featureRoot, "*/utils/*.util.ts"),
+      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>" },
-          { ignoreMiddleExtensions: true },
         ],
       },
     },
@@ -249,20 +254,19 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${sharedPrefixPattern}.util` },
+          { "**/*.ts": sharedPrefixPattern },
         ],
       },
     },
     {
       name: "naming/constants",
-      files: featuresGlob(featureRoot, "*/constants/*.constant.ts"),
+      files: featuresGlob(featureRoot, "*/constants/*.ts"),
       ignores: featuresGlob(featureRoot, "shared/constants/*.ts"),
       plugins: { "check-file": checkFile },
       rules: {
         "check-file/filename-naming-convention": [
           "error",
           { "**/*/constants/*.ts": "<1>" },
-          { ignoreMiddleExtensions: true },
         ],
       },
     },
@@ -273,7 +277,7 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${sharedPrefixPattern}.constant` },
+          { "**/*.ts": sharedPrefixPattern },
         ],
       },
     },
@@ -287,7 +291,7 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
     rules: {
       "check-file/filename-naming-convention": [
         "error",
-        { "**/*.ts": interactorPattern },
+        { "**/*.ts": prefixPattern },
       ],
     },
   });
@@ -300,7 +304,7 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${sharedPrefixPattern}.interactor` },
+          { "**/*.ts": sharedPrefixPattern },
         ],
       },
     },

package/src/next/directives.mjs

@@ -2,7 +2,7 @@
 export const directivesConfigs = [
   {
     name: "directives/server-interactor",
-    files: ["src/features/**/interactors/server.interactor.ts"],
+    files: ["src/features/**/interactors/server.ts"],
     rules: {
       "no-restricted-syntax": [
         "error",
@@ -10,14 +10,14 @@ export const directivesConfigs = [
           selector:
             "Program > :first-child:not(ExpressionStatement[expression.value='use server'])",
           message:
-            'server.interactor.ts must start with "use server" directive.',
+            'interactors/server.ts must start with "use server" directive.',
         },
       ],
     },
   },
   {
     name: "directives/admin-interactor",
-    files: ["src/features/**/interactors/admin.interactor.ts"],
+    files: ["src/features/**/interactors/admin.ts"],
     rules: {
       "no-restricted-syntax": [
         "error",
@@ -25,21 +25,21 @@ export const directivesConfigs = [
           selector:
             "Program > :first-child:not(ExpressionStatement[expression.value='use server'])",
           message:
-            'admin.interactor.ts must start with "use server" directive.',
+            'interactors/admin.ts must start with "use server" directive.',
         },
       ],
     },
   },
   {
     name: "directives/client-interactor",
-    files: ["src/features/**/interactors/client.interactor.ts"],
+    files: ["src/features/**/interactors/client.ts"],
     rules: {
       "no-restricted-syntax": [
         "error",
         {
           selector: "ExpressionStatement[expression.value='use server']",
           message:
-            'client.interactor.ts must NOT have "use server" directive. It uses @/lib/supabase/client.',
+            'interactors/client.ts must NOT have "use server" directive. It uses @/lib/supabase/client.',
         },
       ],
     },