@yasainet/eslint 0.0.54 → 0.0.56

package/package.json

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

package/src/common/imports.mjs

@@ -162,13 +162,27 @@ function makeConfig(name, files, ...patternArrays) {
   };
 }
 
+// In ESLint flat config, when multiple matching configs set the same rule
+// (`no-restricted-imports`), the later config's options REPLACE the earlier
+// ones — patterns are not merged. Page / hooks / components boundary configs
+// run after libBoundaryConfigs and would silently drop lib + mapping bans
+// unless we re-include those patterns explicitly.
 /** Next.js-only: restrict page.tsx to only import interactors. */
 export const pageBoundaryConfigs = [
   {
     name: "imports/page-boundary",
     files: ["src/app/**/page.tsx"],
     rules: {
-      "no-restricted-imports": ["error", { patterns: PAGE_BOUNDARY_PATTERNS }],
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            ...PAGE_BOUNDARY_PATTERNS,
+            ...LIB_BOUNDARY_PATTERNS,
+            ...MAPPING_PATTERNS,
+          ],
+        },
+      ],
     },
   },
 ];
@@ -179,7 +193,16 @@ export const hooksBoundaryConfigs = [
     name: "imports/hooks-boundary",
     files: ["src/features/**/hooks/*.ts"],
     rules: {
-      "no-restricted-imports": ["error", { patterns: HOOKS_BOUNDARY_PATTERNS }],
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            ...HOOKS_BOUNDARY_PATTERNS,
+            ...LIB_BOUNDARY_PATTERNS,
+            ...MAPPING_PATTERNS,
+          ],
+        },
+      ],
     },
   },
 ];
@@ -192,7 +215,13 @@ export const componentsBoundaryConfigs = [
     rules: {
       "no-restricted-imports": [
         "error",
-        { patterns: COMPONENTS_BOUNDARY_PATTERNS },
+        {
+          patterns: [
+            ...COMPONENTS_BOUNDARY_PATTERNS,
+            ...LIB_BOUNDARY_PATTERNS,
+            ...MAPPING_PATTERNS,
+          ],
+        },
       ],
     },
   },

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

@@ -6,6 +6,8 @@ import { noAnyReturnRule } from "./no-any-return.mjs";
 import { queriesExportRule } from "./queries-export.mjs";
 import { queriesNamespaceImportRule } from "./queries-namespace-import.mjs";
 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 = {
@@ -18,5 +20,7 @@ export const localPlugin = {
     "queries-export": queriesExportRule,
     "queries-namespace-import": queriesNamespaceImportRule,
     "schema-naming": schemaNamingRule,
+    "supabase-columns-satisfies": supabaseColumnsSatisfiesRule,
+    "supabase-select-typed-columns": supabaseSelectTypedColumnsRule,
   },
 };

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

@@ -0,0 +1,70 @@
+/**
+ * Enforce `[...] as const satisfies readonly (keyof Tables<"...">)[]` 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.
+ */
+
+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) {
+  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 (ann.typeName.type !== "Identifier") return false;
+  if (ann.typeName.name !== "const") return false;
+  if (inner.expression.type !== "ArrayExpression") return false;
+  return true;
+}
+
+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.',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      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;
+        context.report({
+          node: node.id,
+          messageId: "missing",
+          data: { name: node.id.name },
+        });
+      },
+    };
+  },
+};

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

@@ -0,0 +1,95 @@
+/**
+ * Enforce typed column constants 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.
+ *
+ * `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).
+ *
+ * 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
+ *
+ * Allowed:
+ *   .select(joinColumns(POST_LIST_COLUMNS))  typed constant via project helper
+ *
+ * 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")`).
+ */
+
+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.',
+      shapeArg:
+        '`.select()` argument must be `joinColumns(<X_COLUMNS>)`. Other expressions defeat type inference and column-level review.',
+      naming:
+        "Column constant `{{ name }}` must be UPPER_SNAKE_CASE ending with `_COLUMNS` (e.g. POST_LIST_COLUMNS, POST_DETAIL_COLUMNS).",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== "MemberExpression") return;
+        if (node.callee.property.type !== "Identifier") return;
+        if (node.callee.property.name !== "select") return;
+
+        if (node.arguments.length === 0) {
+          context.report({ node, messageId: "noArgs" });
+          return;
+        }
+
+        const arg = node.arguments[0];
+
+        if (arg.type === "Literal" || arg.type === "TemplateLiteral") {
+          context.report({ node: arg, messageId: "literalArg" });
+          return;
+        }
+
+        const id = asJoinColumnsCall(arg);
+        if (!id) {
+          context.report({ node: arg, messageId: "shapeArg" });
+          return;
+        }
+
+        if (!COLUMNS_NAME.test(id.name)) {
+          context.report({
+            node: id,
+            messageId: "naming",
+            data: { name: id.name },
+          });
+        }
+      },
+    };
+  },
+};

package/src/common/naming.mjs

@@ -118,6 +118,25 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
         "local/queries-namespace-import": "error",
       },
     },
+    {
+      name: "naming/supabase-select",
+      files: featuresGlob(featureRoot, "**/queries/*.query.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/supabase-select-typed-columns": "error",
+      },
+    },
+    {
+      name: "naming/supabase-columns-satisfies",
+      files: [
+        ...featuresGlob(featureRoot, "**/queries/*.query.ts"),
+        ...featuresGlob(featureRoot, "**/constants/*.constant.ts"),
+      ],
+      plugins: { local: localPlugin },
+      rules: {
+        "local/supabase-columns-satisfies": "error",
+      },
+    },
     {
       name: "naming/form-state",
       files: featuresGlob(featureRoot, "**/*.ts"),