@yasainet/eslint 0.0.51 → 0.0.53

package/README.md

@@ -35,7 +35,7 @@ Each entry point enforces a feature-based architecture with the following conven
 ├── shared/             # Cross-feature shared modules
 ├── ...
 {libRoot}/              # *.lib.ts — library wrappers (e.g., supabase.lib.ts)
-{utilsRoot}/            # *.util.ts — top-level utilities
+{utilsRoot}/            # *.util.ts — top-level utilities (e.g., font.util.ts)
 ```
 
 ## Setup

package/package.json

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

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

@@ -0,0 +1,43 @@
+/**
+ * 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) {
+  const name = idNode.name;
+  if (!name.endsWith("FormState")) return;
+  if (FORM_STATE_ALLOW.test(name)) return;
+  context.report({
+    node: idNode,
+    messageId: "invalidName",
+    data: { name },
+  });
+}
+
+export const formStateNamingRule = {
+  meta: {
+    type: "problem",
+    messages: {
+      invalidName:
+        "FormState type '{{ name }}' must follow {Verb}{Subject}FormState pattern (e.g. CreateCommentFormState, SignInFormState). At least two PascalCase words are required.",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      TSInterfaceDeclaration(node) {
+        if (node.id) reportIfInvalid(context, node.id);
+      },
+      TSTypeAliasDeclaration(node) {
+        if (node.id) reportIfInvalid(context, node.id);
+      },
+    };
+  },
+};

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

@@ -1,16 +1,22 @@
 import { featureNameRule } from "./feature-name.mjs";
+import { formStateNamingRule } from "./form-state-naming.mjs";
 import { importPathStyleRule } from "./import-path-style.mjs";
 import { namespaceImportNameRule } from "./namespace-import-name.mjs";
 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";
 
 /** Single plugin object to avoid ESLint "Cannot redefine plugin" errors. */
 export const localPlugin = {
   rules: {
     "feature-name": featureNameRule,
+    "form-state-naming": formStateNamingRule,
     "import-path-style": importPathStyleRule,
     "namespace-import-name": namespaceImportNameRule,
     "no-any-return": noAnyReturnRule,
+    "queries-export": queriesExportRule,
+    "queries-namespace-import": queriesNamespaceImportRule,
     "schema-naming": schemaNamingRule,
   },
 };

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

@@ -0,0 +1,65 @@
+/**
+ * Enforce verb allow list for `queries/*.query.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) {
+  if (!initNode) return false;
+  const t = initNode.type;
+  if (t === "ArrowFunctionExpression" || t === "FunctionExpression") return true;
+  if (t === "CallExpression") {
+    return initNode.arguments.some(
+      (arg) =>
+        arg.type === "ArrowFunctionExpression" ||
+        arg.type === "FunctionExpression",
+    );
+  }
+  return false;
+}
+
+function reportIfInvalid(context, idNode) {
+  if (!QUERIES_ALLOW.test(idNode.name)) {
+    context.report({
+      node: idNode,
+      messageId: "invalidName",
+      data: { name: idNode.name },
+    });
+  }
+}
+
+export const queriesExportRule = {
+  meta: {
+    type: "problem",
+    messages: {
+      invalidName:
+        "queries export '{{ name }}' must start with one of: get, create, update, delete, signUp, signIn, signOut. (Rails 5 actions translated to TS idiom)",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ExportNamedDeclaration(node) {
+        if (!node.declaration) return;
+        const decl = node.declaration;
+
+        if (decl.type === "FunctionDeclaration" && decl.id) {
+          reportIfInvalid(context, decl.id);
+          return;
+        }
+
+        if (decl.type === "VariableDeclaration") {
+          for (const variator of decl.declarations) {
+            if (variator.id.type !== "Identifier") continue;
+            if (!isFunctionLike(variator.init)) continue;
+            reportIfInvalid(context, variator.id);
+          }
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,40 @@
+/**
+ * Enforce namespace imports for `queries/*.query.ts` files.
+ *
+ * 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.
+ */
+
+const QUERIES_PATH = /\/queries\/[^/]+\.query$/;
+
+export const queriesNamespaceImportRule = {
+  meta: {
+    type: "problem",
+    messages: {
+      useNamespace:
+        'Use `import * as xxxQuery from "{{ source }}"` instead of named imports for queries layer. Type-only imports (`import type {}`) are allowed.',
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (typeof node.source.value !== "string") return;
+        if (!QUERIES_PATH.test(node.source.value)) return;
+        if (node.importKind === "type") return;
+
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier") continue;
+          if (specifier.importKind === "type") continue;
+          context.report({
+            node: specifier,
+            messageId: "useNamespace",
+            data: { source: node.source.value },
+          });
+        }
+      },
+    };
+  },
+};

package/src/common/naming.mjs

@@ -102,6 +102,30 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
         ],
       },
     },
+    {
+      name: "naming/queries-export",
+      files: featuresGlob(featureRoot, "**/queries/*.query.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/queries-export": "error",
+      },
+    },
+    {
+      name: "naming/queries-namespace-import",
+      files: featuresGlob(featureRoot, "**/*.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/queries-namespace-import": "error",
+      },
+    },
+    {
+      name: "naming/form-state",
+      files: featuresGlob(featureRoot, "**/*.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/form-state-naming": "error",
+      },
+    },
   );
 
   configs.push(

package/src/common/rules.mjs

@@ -88,9 +88,9 @@ export const rulesConfigs = [
       ],
       "@typescript-eslint/no-explicit-any": "warn",
       // Detect defensive fallbacks on non-nullable values (e.g., `?? ''`
-      // on a non-null column). Kept at warn until existing violations are
-      // cleaned up across consuming projects; promote to error afterwards.
-      "@typescript-eslint/no-unnecessary-condition": "warn",
+      // 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",