@yasainet/eslint 0.0.73 → 0.0.74

package/src/common/local-plugins/entry-template.mjs

@@ -1,58 +1,12 @@
-/**
- * Enforce the canonical entry template for `**\/entries/*.ts` exports.
- *
- * Two body shapes are accepted:
- *
- * - **Pattern A** (read / mutation entries): body is a single try/catch.
- * - **Pattern B** (redirect entries): body contains exactly one try/catch and
- *   ends with a terminal Next.js navigation call (`redirect`, `notFound`,
- *   `permanentRedirect`) — placed *outside* try/catch per the Next.js docs,
- *   since these helpers throw `NEXT_REDIRECT` / `NEXT_NOT_FOUND` and must not
- *   be intercepted by the entry's own catch. Pattern B does not require a
- *   `return { data, error: null }` in the try block (success is the redirect).
- *
- * Both patterns share the same try/catch contract:
- *
- * - try first statement: `logger.info(<obj>, "Start <funcName>")`
- * - try success return preceded by: `logger.info(<obj>, "Success <funcName>")`
- *   (Pattern A only — Pattern B's success path terminates via redirect)
- * - try failed branch (when present): `logger.error(<obj>, "Failed <funcName>")`
- *   followed by a return with the proper error shape
- * - catch param: `error: unknown`
- * - catch first statement: `logger.error(<obj>, "Unexpected error in <funcName>")`
- * - catch return error.message must be the literal "An unexpected error occurred"
- * - every log object must include the `err` key first (when applicable) and
- *   propagate all function input parameters as values
- *
- * Why one rule with many messageIds: each invariant is a small rule
- * conceptually, but they share the same structural traversal and access to
- * funcName / inputArgs. Splitting would duplicate the AST walk.
- */
-
 const CATCH_RETURN_MESSAGE = "An unexpected error occurred";
-const TERMINAL_CALLEES = new Set([
-  "redirect",
-  "permanentRedirect",
-  "notFound",
-]);
+const TERMINAL_CALLEES = new Set(["redirect", "permanentRedirect", "notFound"]);
 
-/**
- * Param identifier names that are excluded from log propagation. These hold
- * secrets that must never be written to logs (Vercel logs are forwarded to
- * external drains, so treating them as sensitive is the conservative default).
- */
 const REDACT_PARAM_NAMES = new Set([
   "password",
   "newPassword",
   "currentPassword",
 ]);
 
-/**
- * Param TypeScript type names that are excluded from log propagation. Supabase
- * credential types contain `password` as a field; logging the whole param leaks
- * the secret. Listed types are matched on the type annotation's identifier
- * name (no type-info resolution; aliases must match by name).
- */
 const REDACT_PARAM_TYPES = new Set([
   "SignUpWithPasswordCredentials",
   "SignInWithPasswordCredentials",
@@ -91,7 +45,8 @@ function isLoggerCall(node, level) {
 
 function getStringLiteralArg(callExpr, index) {
   const arg = callExpr.arguments[index];
-  if (arg?.type === "Literal" && typeof arg.value === "string") return arg.value;
+  if (arg?.type === "Literal" && typeof arg.value === "string")
+    return arg.value;
   return null;
 }
 
@@ -112,7 +67,10 @@ function objectContainsValue(objExpr, identifierName) {
     ) {
       return true;
     }
-    if (prop.value.type === "Identifier" && prop.value.name === identifierName) {
+    if (
+      prop.value.type === "Identifier" &&
+      prop.value.name === identifierName
+    ) {
       return true;
     }
   }
@@ -124,10 +82,10 @@ function firstPropertyIsErrKey(objExpr, errorIdentifierName) {
   const first = objExpr.properties[0];
   if (first.type !== "Property") return false;
   if (first.key.type !== "Identifier" || first.key.name !== "err") return false;
-  // value must be the catch error identifier (or any Identifier — we accept both
-  // `err: error` and `err: result.error` since Failed Pattern C uses MemberExpression)
   if (first.value.type === "Identifier") {
-    return errorIdentifierName ? first.value.name === errorIdentifierName : true;
+    return errorIdentifierName
+      ? first.value.name === errorIdentifierName
+      : true;
   }
   if (first.value.type === "MemberExpression") return true;
   return false;
@@ -201,7 +159,6 @@ function checkLogCall({
 }
 
 function isReturnDataErrorNull(ret) {
-  // `return { data: ..., error: null }` (data shorthand or explicit)
   const arg = ret.argument;
   if (arg?.type !== "ObjectExpression") return false;
   let hasData = false;
@@ -230,8 +187,12 @@ function getReturnErrorMessageLiteral(ret) {
     if (prop.value.type !== "ObjectExpression") return null;
     for (const inner of prop.value.properties) {
       if (inner.type !== "Property") continue;
-      if (inner.key.type !== "Identifier" || inner.key.name !== "message") continue;
-      if (inner.value.type === "Literal" && typeof inner.value.value === "string") {
+      if (inner.key.type !== "Identifier" || inner.key.name !== "message")
+        continue;
+      if (
+        inner.value.type === "Literal" &&
+        typeof inner.value.value === "string"
+      ) {
         return inner.value.value;
       }
       return "<non-literal>";
@@ -283,7 +244,6 @@ function endsWithTerminal(node) {
 }
 
 function caseEndsWithTerminal(switchCase, allCases, idx) {
-  // Empty consequent = fallthrough; inherit next case's terminator.
   if (switchCase.consequent.length === 0) {
     const next = allCases[idx + 1];
     if (!next) return false;
@@ -311,11 +271,14 @@ function classifyBody(body) {
 
 function checkTryBlock(context, tryBlock, funcName, inputArgNames, options) {
   if (tryBlock.body.length === 0) {
-    context.report({ node: tryBlock, messageId: "tryEmpty", data: { funcName } });
+    context.report({
+      node: tryBlock,
+      messageId: "tryEmpty",
+      data: { funcName },
+    });
     return;
   }
 
-  // Start log: first statement
   const first = tryBlock.body[0];
   if (!isExpressionStatementWithLoggerCall(first, "info")) {
     context.report({
@@ -337,16 +300,12 @@ function checkTryBlock(context, tryBlock, funcName, inputArgNames, options) {
     });
   }
 
-  // Walk body to find Success returns and Failed branches
   let successFound = false;
   for (let i = 0; i < tryBlock.body.length; i++) {
     const stmt = tryBlock.body[i];
 
-    // Success log + return
     if (stmt.type === "ReturnStatement" && isReturnDataErrorNull(stmt)) {
       successFound = true;
-      // The previous non-ExpressionStatement non-IfStatement statement should be
-      // the Success log. Walk back to find it.
       const prev = findPrecedingLoggerCall(tryBlock.body, i);
       if (
         !prev ||
@@ -373,7 +332,6 @@ function checkTryBlock(context, tryBlock, funcName, inputArgNames, options) {
       }
     }
 
-    // Failed branches inside if statements
     if (stmt.type === "IfStatement") {
       checkFailedBranch(context, stmt, funcName, inputArgNames);
     }
@@ -396,7 +354,6 @@ function findPrecedingLoggerCall(body, returnIndex) {
       s.type === "ExpressionStatement" &&
       s.expression.type === "AwaitExpression"
     ) {
-      // `await revalidatePath(...)` etc — keep walking
       continue;
     }
     if (s.type === "ExpressionStatement") {
@@ -409,16 +366,13 @@ function findPrecedingLoggerCall(body, returnIndex) {
 }
 
 function checkFailedBranch(context, ifStmt, funcName, inputArgNames) {
-  // We only validate IFs that look like Failed branches: contain a return whose
-  // error.message is a string literal (not the catch's "An unexpected ..." literal).
   const consequent = ifStmt.consequent;
   if (consequent.type !== "BlockStatement") return;
   const ret = consequent.body.find((s) => s.type === "ReturnStatement");
   if (!ret) return;
   const errMsg = getReturnErrorMessageLiteral(ret);
-  if (errMsg === null) return; // not a Failed-shaped return; skip
+  if (errMsg === null) return;
 
-  // Must have logger.error("Failed <funcName>") preceding the return
   const idx = consequent.body.indexOf(ret);
   let loggerCall = null;
   for (let j = 0; j < idx; j++) {
@@ -440,7 +394,7 @@ function checkFailedBranch(context, ifStmt, funcName, inputArgNames) {
     return;
   }
 
-  const isPatternC = errMsg === "<non-literal>"; // .message access
+  const isPatternC = errMsg === "<non-literal>";
   checkLogCall({
     context,
     callExpr: loggerCall,
@@ -471,7 +425,11 @@ function checkCatchClause(context, handler, funcName, inputArgNames) {
   }
   const block = handler.body;
   if (block.body.length === 0) {
-    context.report({ node: block, messageId: "catchEmpty", data: { funcName } });
+    context.report({
+      node: block,
+      messageId: "catchEmpty",
+      data: { funcName },
+    });
     return;
   }
   const first = block.body[0];
@@ -495,7 +453,6 @@ function checkCatchClause(context, handler, funcName, inputArgNames) {
     });
   }
 
-  // Last statement must be a return whose error.message is the catch literal
   const last = block.body[block.body.length - 1];
   if (last?.type !== "ReturnStatement") {
     context.report({
@@ -510,7 +467,11 @@ function checkCatchClause(context, handler, funcName, inputArgNames) {
     context.report({
       node: last,
       messageId: "catchWrongReturnMessage",
-      data: { funcName, expected: CATCH_RETURN_MESSAGE, actual: msg ?? "<missing>" },
+      data: {
+        funcName,
+        expected: CATCH_RETURN_MESSAGE,
+        actual: msg ?? "<missing>",
+      },
     });
   }
 }

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

@@ -1,11 +1,6 @@
 import fs from "fs";
 import path from "path";
 
-/**
- * Extract table names from Supabase generated types file.
- * Looks for top-level keys under `Tables: {` inside the `public` schema.
- * Uses brace counting to handle deeply nested type definitions.
- */
 function extractTableNames(supabaseTypePath) {
   if (!fs.existsSync(supabaseTypePath)) {
     return [];
@@ -13,7 +8,6 @@ function extractTableNames(supabaseTypePath) {
 
   const content = fs.readFileSync(supabaseTypePath, "utf-8");
 
-  // Find `public:` excluding `graphql_public:` via negative lookbehind
   const publicMatch = /(?<!\w)public:\s*\{/.exec(content);
   if (!publicMatch) {
     return [];
@@ -25,13 +19,11 @@ function extractTableNames(supabaseTypePath) {
     return [];
   }
 
-  // Find the opening brace of `Tables: {`
   const braceStart = content.indexOf("{", tablesIdx + tablesLabel.length);
   if (braceStart === -1) {
     return [];
   }
 
-  // Extract the Tables block using brace counting
   let depth = 0;
   let blockEnd = -1;
   for (let i = braceStart; i < content.length; i++) {
@@ -46,14 +38,12 @@ function extractTableNames(supabaseTypePath) {
     return [];
   }
 
-  // Extract top-level keys (depth 0) inside the Tables block
   const tablesBlock = content.slice(braceStart + 1, blockEnd);
   const names = [];
   depth = 0;
   const keyRegex = /(\w+)\s*:/g;
   let match;
   while ((match = keyRegex.exec(tablesBlock)) !== null) {
-    // Count braces before this match to determine depth
     const preceding = tablesBlock.slice(0, match.index);
     let d = 0;
     for (const ch of preceding) {
@@ -67,15 +57,10 @@ function extractTableNames(supabaseTypePath) {
   return names;
 }
 
-/** Convert snake_case to kebab-case. */
 function toKebab(name) {
   return name.replace(/_/g, "-");
 }
 
-/**
- * Enforce that feature directory names match allowed values:
- * "shared", "auth", plus Supabase table names converted to kebab-case.
- */
 export const featureNameRule = {
   meta: {
     type: "problem",
@@ -107,14 +92,15 @@ export const featureNameRule = {
     if (!featureName) return {};
 
     const projectRoot = filename.slice(0, rootIdx).replace(/\/src$/, "");
-    // Prefer the Supabase types file adjacent to `featureRoot` (e.g. `src/lib/...`
-    // for `src/features`). Fall back to `src/lib/...` at the project root so that
-    // non-`src` feature roots (e.g. `scripts/features`) can reuse the same
-    // generated types without duplicating the file. Both `types.ts` (plural) and
-    // `type.ts` (singular) are accepted to match either naming convention.
     const candidateTypePaths = [
-      path.join(projectRoot, featureRoot.replace(/features$/, "lib/supabase/types.ts")),
-      path.join(projectRoot, featureRoot.replace(/features$/, "lib/supabase/type.ts")),
+      path.join(
+        projectRoot,
+        featureRoot.replace(/features$/, "lib/supabase/types.ts"),
+      ),
+      path.join(
+        projectRoot,
+        featureRoot.replace(/features$/, "lib/supabase/type.ts"),
+      ),
       path.join(projectRoot, "src/lib/supabase/types.ts"),
       path.join(projectRoot, "src/lib/supabase/type.ts"),
     ];

package/src/common/local-plugins/form-state-naming.mjs

@@ -1,13 +1,3 @@
-/**
- * Enforce {Verb}{Subject}FormState pattern for FormState type names.
- *
- * Targets TSInterfaceDeclaration and TSTypeAliasDeclaration whose name ends
- * with "FormState". Requires at least two PascalCase words before FormState
- * (e.g. SignInFormState, CreateCommentFormState) so the verb prefix is never
- * omitted. Single-noun names like "ContactFormState" are forbidden — rename
- * to "CreateContactFormState" to make intent explicit.
- */
-
 const FORM_STATE_ALLOW = /^[A-Z][a-z]+[A-Z]\w*FormState$/;
 
 function reportIfInvalid(context, idNode) {

package/src/common/local-plugins/form-state-shape.mjs

@@ -1,37 +1,3 @@
-/**
- * Enforce the canonical `{ data, error: { message } }` shape for FormState types.
- *
- * Targets `TSInterfaceDeclaration` and `TSTypeAliasDeclaration` whose name ends
- * with `FormState`. Required shape:
- *
- * ```ts
- * interface XxxFormState {
- *   data: T | null;            // T may be any type; `data: null` literal also OK
- *   error: { message: string } | null;
- * }
- * ```
- *
- * Why this shape:
- *
- * - Single uniform shape lets entry / hook / UI be templated and lint-checked.
- * - Forbids `code` / `status` / similar discriminator fields that tend to grow
- *   defensive branches (e.g. `error.code === "unauthenticated"`) which usually
- *   indicate a missing upstream guard (route gate, button conditional render),
- *   not a legitimate need for in-action discrimination.
- * - Discriminated unions (`{ data: T; error: null } | { data: null; error: ... }`)
- *   are rejected for the same reason — they leak shape complexity into hooks
- *   (`useActionState<T | null>`), components (`state?.error`), and entries.
- *
- * Future extension when Stripe / payment libraries actually need `code` / `status`:
- *
- * - a) Add a `// allow-error-code: <reason>` comment opt-out to this rule, so
- *      individual FormStates can justify their extra field on the previous line.
- * - b) Change the rule to whitelist a fixed set of allowed extra fields (enum
- *      of standard error codes shared across the codebase).
- *
- * Until that need materializes, this rule is strict (no opt-out) per YAGNI.
- */
-
 const FORM_STATE_SUFFIX = "FormState";
 
 function isNullLiteralType(node) {

package/src/common/local-plugins/import-path-style.mjs

@@ -1,10 +1,5 @@
 import path from "path";
 
-/**
- * Enforce import path style within features:
- * - Same-feature imports must use relative paths
- * - Cross-feature imports must use @/ alias
- */
 export const importPathStyleRule = {
   meta: {
     type: "problem",
@@ -48,7 +43,6 @@ export const importPathStyleRule = {
       if (!source || typeof source.value !== "string") return;
       const importPath = source.value;
 
-      // Same-feature alias should be a relative path for consistency.
       if (
         importPath.startsWith(sameFeaturePrefix) ||
         importPath === sameFeatureExact
@@ -61,7 +55,6 @@ export const importPathStyleRule = {
         return;
       }
 
-      // Cross-feature relative path should use @/ alias for clarity.
       if (importPath.startsWith(".")) {
         const resolved = path.resolve(path.dirname(filename), importPath);
         if (

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

@@ -13,7 +13,6 @@ import { schemaNamingRule } from "./schema-naming.mjs";
 import { supabaseColumnsSatisfiesRule } from "./supabase-columns-satisfies.mjs";
 import { supabaseSelectTypedColumnsRule } from "./supabase-select-typed-columns.mjs";
 
-/** Single plugin object to avoid ESLint "Cannot redefine plugin" errors. */
 export const localPlugin = {
   rules: {
     "entry-single-service-call": entrySingleServiceCallRule,

package/src/common/local-plugins/layout-main-structural-only.mjs

@@ -1,24 +1,3 @@
-/**
- * Forbid decoration utility classes on the `<main>` element.
- *
- * Design philosophy: `app/**\/layout.tsx` の `<main>` は Header / Footer の
- * 縦積みを受け持つ構造スロット。装飾（余白・間隔）は page.tsx 側の Container 等が
- * 持つべき。main に padding / margin / gap を直接当てると、page 全体に暗黙の
- * オフセットが生まれ、page ごとの調整余地が失われる。
- *
- * Disallowed Tailwind token prefixes (case-sensitive):
- *
- * - `p`, `m`, `py`, `px`, `pt`, `pb`, `pl`, `pr`, `my`, `mx`, `mt`, `mb`, `ml`, `mr` — padding / margin
- * - `space-x`, `space-y` — sibling spacing
- * - `gap` — flex / grid gap
- *
- * Allowed: structural utilities (`flex`, `flex-1`, `flex-col`, `min-h-*`,
- * `block`, `relative`, etc.)
- *
- * className value forms supported: string Literal, TemplateLiteral,
- * `cn(...)` / `clsx(...)` style CallExpression args (string args only).
- */
-
 const DISALLOWED_TOKEN = /^(?:[pm][xytrbl]?-|space-[xy]-|gap-)/;
 
 function collectStringLiterals(node, out) {

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

@@ -1,13 +1,3 @@
-/**
- * Enforce consistent naming for `import * as` namespace imports
- * within feature-based architecture.
- *
- * Convention: import * as {featureName}{Scope}{Layer} from "{path}/{layerDir}/{scope}"
- *
- * Layer はファイル名 suffix ではなくディレクトリ名 (`queries/` / `services/` 等) から識別する。
- */
-
-/** @type {Record<string, string>} */
 const LAYER_DIR_MAP = {
   queries: "Query",
   services: "Service",
@@ -19,39 +9,27 @@ const LAYER_DIR_MAP = {
   constants: "Constant",
 };
 
-/** Convert a snake_case or kebab-case string to camelCase. */
 function toCamelCase(str) {
   return str.replace(/[-_]+(.)/g, (_, c) => c.toUpperCase());
 }
 
-/** Convert a snake_case or kebab-case string to PascalCase. */
 function toPascalCase(str) {
   const camel = toCamelCase(str);
   return camel.charAt(0).toUpperCase() + camel.slice(1);
 }
 
-/**
- * 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/...
   let normalized = importPath;
   const aliasBase = featureRoot.replace(/^src\//, "@/");
   if (normalized.startsWith(aliasBase + "/")) {
     normalized = featureRoot + normalized.slice(aliasBase.length);
   }
 
-  // Only process paths within the feature root
   const rootPrefix = featureRoot + "/";
   const rootIdx = normalized.indexOf(rootPrefix);
   if (rootIdx === -1) return null;
 
   const afterRoot = normalized.slice(rootIdx + rootPrefix.length);
-  // Expected: {feature}/{layerDir}/{scope}
   const segments = afterRoot.split("/");
   if (segments.length < 3) return null;
 
@@ -65,7 +43,6 @@ function parseImportSource(importPath, featureRoot) {
   return { featureDir, scope, layer };
 }
 
-/** Build the expected namespace import name. */
 function buildExpectedName(featureDir, scope, layer) {
   const featureCamel = toCamelCase(featureDir);
   const scopePascal = toPascalCase(scope);
@@ -96,7 +73,6 @@ export const namespaceImportNameRule = {
 
     return {
       ImportDeclaration(node) {
-        // Only check namespace imports: import * as Name
         const nsSpecifier = node.specifiers.find(
           (s) => s.type === "ImportNamespaceSpecifier",
         );
@@ -104,7 +80,6 @@ export const namespaceImportNameRule = {
 
         const importPath = node.source.value;
 
-        // Skip external/built-in imports (only check relative and alias)
         if (
           !importPath.startsWith("./") &&
           !importPath.startsWith("../") &&
@@ -113,7 +88,6 @@ export const namespaceImportNameRule = {
           return;
         }
 
-        // For relative imports, resolve to an absolute-like path for parsing
         let resolvedPath = importPath;
         if (importPath.startsWith(".")) {
           const fileDir = context.filename.replace(/\/[^/]+$/, "");

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

@@ -1,12 +1,5 @@
 import ts from "typescript";
 
-/**
- * Exported function の return type が any を含んでいる場合に error:
- *
- * - typescript-eslint の type checker を使って inferred type まで見る
- * - queries / services の API 境界を any 汚染から守ることで、domain shape が型で保証される
- * - Promise<any>, Promise<{ data: any }>, Array<any> など nested も展開して検査する
- */
 export const noAnyReturnRule = {
   meta: {
     type: "problem",
@@ -41,7 +34,6 @@ export const noAnyReturnRule = {
       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;

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

@@ -1,11 +1,3 @@
-/**
- * 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
- */
-
 const QUERIES_ALLOW = /^(get|create|update|delete|signUp|signIn|signOut)([A-Z]|$)/;
 
 function isFunctionLike(initNode) {

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

@@ -1,13 +1,3 @@
-/**
- * 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
- * - 検出は path に `/queries/<name>` が含まれることのみで行い、suffix には依存しない
- */
-
 const QUERIES_PATH = /\/queries\/[^/]+$/;
 
 export const queriesNamespaceImportRule = {

package/src/common/local-plugins/schema-naming.mjs

@@ -1,9 +1,3 @@
-/**
- * Enforce that exported variables in schema files use camelCase with a "Schema" suffix.
- * e.g., `export const userSchema = z.object(...)` is valid.
- *       `export const UserSchema = ...` or `export const user = ...` are invalid.
- * `export type` declarations are ignored (used for `z.infer` types).
- */
 export const schemaNamingRule = {
   meta: {
     type: "problem",

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

@@ -1,27 +1,3 @@
-/**
- * Enforce `<string literal> as const` for `*_COLUMNS` constant declarations.
- *
- * 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$/;
 
 function isStringAsConst(initNode) {

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

@@ -1,35 +1,3 @@
-/**
- * Enforce explicit column lists for Supabase `.select()` calls.
- *
- * Apply to `**\/queries/*.ts`. `.select()` の引数は次のいずれかでなければならない:
- *
- * - 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(`${x},y`)            dynamic concatenation
- *   .select(cols.join(","))      runtime expression
- *   .select(someVar)             non-conforming variable
- *
- * Allowed:
- *   .select("id,url,platform")        inline literal
- *   .select(POST_DETAIL_COLUMNS)      *_COLUMNS named constant
- *
- * 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$/;
 
 export const supabaseSelectTypedColumnsRule = {