@yasainet/eslint 0.0.53 → 0.0.55

package/package.json

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

package/src/common/index.mjs

@@ -3,20 +3,30 @@ import { createImportsConfigs } from "./imports.mjs";
 import { createJsdocConfigs } from "./jsdoc.mjs";
 import { createLayersConfigs } from "./layers.mjs";
 import { createLibNamingConfigs, createNamingConfigs, createUtilsNamingConfigs } from "./naming.mjs";
-import { rulesConfigs } from "./rules.mjs";
+import { createRulesConfigs } from "./rules.mjs";
 
-/** Build common configs scoped to the given feature root. */
+/**
+ * Build common configs scoped to the given feature root:
+ *
+ * - `banAliasImports: true` enforces relative imports inside the feature root
+ * - `typeAware: false` disables type-aware rules and `local/no-any-return`,
+ *   for environments without a project tsconfig (e.g., Deno entry)
+ * - `rulesFiles` narrows the parser/rules block. Pass when combining multiple
+ *   entries so each entry only overrides its own files (e.g., the deno entry
+ *   passes `["supabase/functions/**\/*.ts"]` so it doesn't override next's
+ *   parser settings on `src/`).
+ */
 export function createCommonConfigs(
   featureRoot,
-  { banAliasImports = false } = {},
+  { banAliasImports = false, typeAware = true, rulesFiles } = {},
 ) {
   const prefixLibMapping = generatePrefixLibMapping(featureRoot);
   return [
-    ...rulesConfigs,
+    ...createRulesConfigs({ typeAware, ...(rulesFiles && { files: rulesFiles }) }),
     ...createNamingConfigs(featureRoot, prefixLibMapping),
     ...createLibNamingConfigs(featureRoot),
     ...createUtilsNamingConfigs(featureRoot),
-    ...createLayersConfigs(featureRoot),
+    ...createLayersConfigs(featureRoot, { typeAware }),
     ...createImportsConfigs(featureRoot, prefixLibMapping, { banAliasImports }),
     ...createJsdocConfigs(featureRoot),
   ];

package/src/common/layers.mjs

@@ -1,11 +1,30 @@
 import { localPlugin } from "./local-plugins/index.mjs";
 
-/** Scope layer rules to the given feature root. */
-export function createLayersConfigs(featureRoot) {
+/**
+ * Scope layer rules to the given feature root:
+ *
+ * - `typeAware: true` (default) includes `layers/no-any-return`, which uses
+ *   the TypeScript checker to inspect inferred return types
+ * - `typeAware: false` skips it for environments where the checker cannot run
+ *   (e.g., Deno files outside the project tsconfig)
+ */
+export function createLayersConfigs(featureRoot, { typeAware = true } = {}) {
   const loggerSelector = "CallExpression[callee.object.name='logger']";
   const loggerMessage =
     "logger is not allowed outside interactors. Logging belongs in interactors.";
 
+  const noAnyReturnConfig = {
+    name: "layers/no-any-return",
+    files: [
+      `${featureRoot}/**/queries/*.ts`,
+      `${featureRoot}/**/services/*.ts`,
+    ],
+    plugins: { local: localPlugin },
+    rules: {
+      "local/no-any-return": "error",
+    },
+  };
+
   return [
     // Logger/console: all features except interactors
     {
@@ -74,17 +93,7 @@ export function createLayersConfigs(featureRoot) {
     // Boundary type safety: queries & 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}/**/queries/*.ts`,
-        `${featureRoot}/**/services/*.ts`,
-      ],
-      plugins: { local: localPlugin },
-      rules: {
-        "local/no-any-return": "error",
-      },
-    },
+    ...(typeAware ? [noAnyReturnConfig] : []),
     // Services: try-catch + logger + dead error fallbacks
     {
       name: "layers/services",

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"),

package/src/common/rules.mjs

@@ -23,87 +23,116 @@ const findProjectRoot = (start) => {
 
 const projectRoot = findProjectRoot(import.meta.dirname);
 
-/** Base rule configs for code style and TypeScript checks. */
-export const rulesConfigs = [
-  {
-    name: "rules/shared",
-    plugins: {
-      "@stylistic": stylistic,
-      "simple-import-sort": simpleImportSortPlugin,
-    },
-    rules: {
-      "no-console": "warn",
-      "no-irregular-whitespace": [
-        "warn",
-        {
-          skipStrings: false,
-          skipComments: false,
-          skipRegExps: false,
-          skipTemplates: false,
-        },
-      ],
-      "simple-import-sort/imports": "warn",
-      "simple-import-sort/exports": "warn",
-      "@stylistic/quotes": ["warn", "double", { avoidEscape: true }],
-      // Dead code detection: rules with no legitimate use case, so always safe to error.
-      "no-unreachable": "error",
-      "no-unreachable-loop": "error",
-      "no-useless-return": "error",
-      "no-constant-condition": "error",
-      "no-constant-binary-expression": "error",
-      "no-dupe-else-if": "error",
-      "no-self-assign": "error",
-      "no-self-compare": "error",
-      "no-useless-catch": "error",
-      "no-fallthrough": "error",
-    },
+const sharedRulesConfig = {
+  name: "rules/shared",
+  plugins: {
+    "@stylistic": stylistic,
+    "simple-import-sort": simpleImportSortPlugin,
   },
-  {
-    name: "rules/typescript",
-    files: ["**/*.ts", "**/*.tsx"],
-    languageOptions: {
-      parser: tseslint.parser,
-      // Enable type-aware linting so rules like `no-unnecessary-condition`
-      // can consult the TypeScript type checker.
-      parserOptions: {
-        projectService: true,
-        tsconfigRootDir: projectRoot,
+  rules: {
+    "no-console": "warn",
+    "no-irregular-whitespace": [
+      "warn",
+      {
+        skipStrings: false,
+        skipComments: false,
+        skipRegExps: false,
+        skipTemplates: false,
       },
+    ],
+    "simple-import-sort/imports": "warn",
+    "simple-import-sort/exports": "warn",
+    "@stylistic/quotes": ["warn", "double", { avoidEscape: true }],
+    // Dead code detection: rules with no legitimate use case, so always safe to error.
+    "no-unreachable": "error",
+    "no-unreachable-loop": "error",
+    "no-useless-return": "error",
+    "no-constant-condition": "error",
+    "no-constant-binary-expression": "error",
+    "no-dupe-else-if": "error",
+    "no-self-assign": "error",
+    "no-self-compare": "error",
+    "no-useless-catch": "error",
+    "no-fallthrough": "error",
+  },
+};
+
+const syntacticTypeScriptRules = {
+  "@typescript-eslint/no-unused-vars": [
+    "error",
+    {
+      argsIgnorePattern: "^_",
+      varsIgnorePattern: "^_",
+      caughtErrorsIgnorePattern: "^_",
     },
-    plugins: {
-      "@typescript-eslint": tseslint.plugin,
-    },
-    rules: {
-      "@typescript-eslint/no-unused-vars": [
-        "error",
-        {
-          argsIgnorePattern: "^_",
-          varsIgnorePattern: "^_",
-          caughtErrorsIgnorePattern: "^_",
-        },
-      ],
-      "@typescript-eslint/consistent-type-imports": [
-        "error",
-        { prefer: "type-imports" },
-      ],
-      "@typescript-eslint/no-explicit-any": "warn",
-      // Detect defensive fallbacks on non-nullable values (e.g., `?? ''`
-      // on a non-null column). Promoted to error once consuming projects
-      // (bitcomic.net, getpayme.net) reached 0 warnings.
-      "@typescript-eslint/no-unnecessary-condition": "error",
-      // 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",
+  ],
+  "@typescript-eslint/consistent-type-imports": [
+    "error",
+    { prefer: "type-imports" },
+  ],
+  "@typescript-eslint/no-explicit-any": "warn",
+};
+
+const typeAwareTypeScriptRules = {
+  // Detect defensive fallbacks on non-nullable values (e.g., `?? ''`
+  // on a non-null column). Promoted to error once consuming projects
+  // (bitcomic.net, getpayme.net) reached 0 warnings.
+  "@typescript-eslint/no-unnecessary-condition": "error",
+  // 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",
+};
+
+const typeAwareRulesOff = Object.fromEntries(
+  Object.keys(typeAwareTypeScriptRules).map((rule) => [rule, "off"]),
+);
+
+/**
+ * Build base rule configs:
+ *
+ * - `typeAware: true` (default) enables `projectService` and type-aware rules
+ *   (`no-unnecessary-condition`, `no-floating-promises`, `no-unsafe-*`, etc.)
+ *   for the matched `files`
+ * - `typeAware: false` disables `projectService` and forces type-aware rules
+ *   off for the matched `files`. Use for files outside the project tsconfig
+ *   (e.g., Deno files in Supabase Edge Functions)
+ *
+ * `files` defaults to all TypeScript sources. When combining multiple entries
+ * (e.g., next + deno), pass a narrow pattern so the type-aware override only
+ * applies to its target files.
+ */
+export function createRulesConfigs({
+  typeAware = true,
+  files = ["**/*.ts", "**/*.tsx"],
+} = {}) {
+  return [
+    sharedRulesConfig,
+    {
+      name: "rules/typescript",
+      files,
+      languageOptions: {
+        parser: tseslint.parser,
+        parserOptions: typeAware
+          ? { projectService: true, tsconfigRootDir: projectRoot }
+          : { projectService: false, project: null },
+      },
+      plugins: {
+        "@typescript-eslint": tseslint.plugin,
+      },
+      rules: {
+        ...syntacticTypeScriptRules,
+        ...(typeAware ? typeAwareTypeScriptRules : typeAwareRulesOff),
+      },
     },
-  },
-];
+  ];
+}

package/src/deno/index.mjs

@@ -9,9 +9,21 @@ const denoEntryPointConfigs = createEntryPointConfigs(
   ["supabase/functions/_*/**"],
 );
 
+// Deno files are not covered by the consumer's project tsconfig
+// (Supabase functions live outside Next.js's tsconfig), so type-aware
+// rules cannot consult the type checker. Disable them here and rely on
+// `deno check` / `deno lint` for type-level guarantees.
+//
+// `rulesFiles` is narrowed so the override only affects Deno files. When this
+// entry is combined with `next`/`node`, those entries keep their type-aware
+// settings on their own files.
 /** Deno ESLint flat config entry point. */
 export const eslintConfig = [
-  ...createCommonConfigs(FEATURE_ROOT, { banAliasImports: true }),
+  ...createCommonConfigs(FEATURE_ROOT, {
+    banAliasImports: true,
+    typeAware: false,
+    rulesFiles: ["supabase/functions/**/*.ts"],
+  }),
   ...denoImportsConfigs,
   ...denoEntryPointConfigs,
 ];