@yasainet/eslint 0.0.57 → 0.0.58

package/package.json

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

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/*.query.ts` and `**\/constants/*.constant.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/*.query.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" });
       },
     };
   },