@yasainet/eslint 0.0.33 → 0.0.35

package/package.json

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

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

@@ -3,7 +3,8 @@ import path from "path";
 
 /**
  * Extract table names from Supabase generated types file.
- * Looks for keys directly under `Tables: {` in the Database interface.
+ * 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)) {
@@ -11,17 +12,57 @@ function extractTableNames(supabaseTypePath) {
   }
 
   const content = fs.readFileSync(supabaseTypePath, "utf-8");
-  const tablesMatch = content.match(/Tables:\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/);
-  if (!tablesMatch) {
+
+  // Find `public:` excluding `graphql_public:` via negative lookbehind
+  const publicMatch = /(?<!\w)public:\s*\{/.exec(content);
+  if (!publicMatch) {
+    return [];
+  }
+
+  const tablesLabel = "Tables:";
+  const tablesIdx = content.indexOf(tablesLabel, publicMatch.index);
+  if (tablesIdx === -1) {
+    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++) {
+    if (content[i] === "{") depth++;
+    else if (content[i] === "}") depth--;
+    if (depth === 0) {
+      blockEnd = i;
+      break;
+    }
+  }
+  if (blockEnd === -1) {
     return [];
   }
 
-  const tablesBlock = tablesMatch[1];
-  const keyRegex = /^\s*(\w+)\s*:/gm;
+  // 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) {
-    names.push(match[1]);
+    // Count braces before this match to determine depth
+    const preceding = tablesBlock.slice(0, match.index);
+    let d = 0;
+    for (const ch of preceding) {
+      if (ch === "{") d++;
+      else if (ch === "}") d--;
+    }
+    if (d === 0) {
+      names.push(match[1]);
+    }
   }
   return names;
 }

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

@@ -2,6 +2,7 @@ import { actionHandleServiceRule } from "./action-handle-service.mjs";
 import { featureNameRule } from "./feature-name.mjs";
 import { importPathStyleRule } from "./import-path-style.mjs";
 import { namespaceImportNameRule } from "./namespace-import-name.mjs";
+import { schemaNamingRule } from "./schema-naming.mjs";
 
 /** Single plugin object to avoid ESLint "Cannot redefine plugin" errors. */
 export const localPlugin = {
@@ -10,5 +11,6 @@ export const localPlugin = {
     "feature-name": featureNameRule,
     "import-path-style": importPathStyleRule,
     "namespace-import-name": namespaceImportNameRule,
+    "schema-naming": schemaNamingRule,
   },
 };

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

@@ -0,0 +1,45 @@
+/**
+ * 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",
+    messages: {
+      missingSuffix:
+        "Exported variable '{{ name }}' in a schema file must end with 'Schema'.",
+      invalidCasing:
+        "Exported variable '{{ name }}' must be camelCase (start with a lowercase letter).",
+    },
+    schema: [],
+  },
+  create(context) {
+    return {
+      ExportNamedDeclaration(node) {
+        if (!node.declaration || node.declaration.type !== "VariableDeclaration") {
+          return;
+        }
+
+        for (const declarator of node.declaration.declarations) {
+          const name = declarator.id.name;
+
+          if (!name.endsWith("Schema")) {
+            context.report({
+              node: declarator.id,
+              messageId: "missingSuffix",
+              data: { name },
+            });
+          } else if (name[0] !== name[0].toLowerCase()) {
+            context.report({
+              node: declarator.id,
+              messageId: "invalidCasing",
+              data: { name },
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/src/common/naming.mjs

@@ -167,6 +167,14 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
         ],
       },
     },
+    {
+      name: "naming/schema-naming",
+      files: featuresGlob(featureRoot, "**/schemas/*.schema.ts"),
+      plugins: { local: localPlugin },
+      rules: {
+        "local/schema-naming": "error",
+      },
+    },
     {
       name: "naming/schemas-shared",
       files: featuresGlob(featureRoot, "shared/schemas/*.ts"),