@yasainet/eslint 0.0.24 → 0.0.26

package/package.json

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

package/src/common/imports.mjs

@@ -92,7 +92,7 @@ function prefixLibPatterns(prefix, mapping) {
 
 const LIB_BOUNDARY_PATTERNS = [
   {
-    group: ["**/lib/*", "**/lib/**"],
+    group: ["@/lib/*", "@/lib/**"],
     message:
       "lib/* can only be imported from repositories (lib-boundary violation)",
   },

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

@@ -1,10 +1,12 @@
 import { actionHandleServiceRule } from "./action-handle-service.mjs";
 import { importPathStyleRule } from "./import-path-style.mjs";
+import { namespaceImportNameRule } from "./namespace-import-name.mjs";
 
 /** Single plugin object to avoid ESLint "Cannot redefine plugin" errors. */
 export const localPlugin = {
   rules: {
     "action-handle-service": actionHandleServiceRule,
     "import-path-style": importPathStyleRule,
+    "namespace-import-name": namespaceImportNameRule,
   },
 };

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

@@ -0,0 +1,150 @@
+/**
+ * Enforce consistent naming for `import * as` namespace imports
+ * within feature-based architecture.
+ *
+ * Convention: import * as {featureName}{Scope}{Layer} from "{path}/{scope}.{layerExt}"
+ */
+
+/** @type {Record<string, string>} */
+const LAYER_MAP = {
+  repo: "Repository",
+  service: "Service",
+  domain: "Domain",
+  action: "Action",
+  util: "Util",
+  type: "Type",
+  schema: "Schema",
+  constant: "Constant",
+};
+
+/** Convert a snake_case or kebab-case string to camelCase. */
+function toCamelCase(str) {
+  return str.replace(/[-_]+(.)/g, (_, c) => c.toUpperCase());
+}
+
+/** Convert a snake_case or kebab-case string to PascalCase. */
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+/**
+ * Parse import source to extract featureName, scope, and layer.
+ * Returns null if the source doesn't match the expected pattern.
+ */
+function parseImportSource(importPath, featureRoot) {
+  // Normalize alias: @/features/... → features/...
+  let normalized = importPath;
+  const aliasBase = featureRoot.replace(/^src\//, "@/");
+  if (normalized.startsWith(aliasBase + "/")) {
+    normalized = featureRoot + normalized.slice(aliasBase.length);
+  }
+
+  // Only process paths within the feature root
+  const rootPrefix = featureRoot + "/";
+  if (!normalized.startsWith(rootPrefix)) return null;
+
+  const afterRoot = normalized.slice(rootPrefix.length);
+  // Expected: {feature}/{layerDir}/{scope}.{layerExt}
+  const segments = afterRoot.split("/");
+  if (segments.length < 2) return null;
+
+  const featureDir = segments[0];
+  const fileName = segments[segments.length - 1];
+
+  const dotIdx = fileName.indexOf(".");
+  if (dotIdx === -1) return null;
+
+  const scope = fileName.slice(0, dotIdx);
+  const ext = fileName.slice(dotIdx + 1);
+
+  const layer = LAYER_MAP[ext];
+  if (!layer) return null;
+
+  return { featureDir, scope, layer };
+}
+
+/** Build the expected namespace import name. */
+function buildExpectedName(featureDir, scope, layer) {
+  const featureCamel = toCamelCase(featureDir);
+  const scopePascal = toPascalCase(scope);
+
+  // Dedup: if feature is "shared" or featureName === scope, omit feature prefix
+  if (featureDir === "shared" || featureCamel === scope) {
+    return scope + layer;
+  }
+
+  return featureCamel + scopePascal + layer;
+}
+
+export const namespaceImportNameRule = {
+  meta: {
+    type: "suggestion",
+    messages: {
+      mismatch:
+        "Namespace import should be named '{{ expected }}' instead of '{{ actual }}'.",
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          featureRoot: { type: "string" },
+        },
+        required: ["featureRoot"],
+        additionalProperties: false,
+      },
+    ],
+  },
+  create(context) {
+    const { featureRoot } = context.options[0];
+
+    return {
+      ImportDeclaration(node) {
+        // Only check namespace imports: import * as Name
+        const nsSpecifier = node.specifiers.find(
+          (s) => s.type === "ImportNamespaceSpecifier",
+        );
+        if (!nsSpecifier) return;
+
+        const importPath = node.source.value;
+
+        // Skip external/built-in imports (only check relative and alias)
+        if (
+          !importPath.startsWith("./") &&
+          !importPath.startsWith("../") &&
+          !importPath.startsWith("@/")
+        ) {
+          return;
+        }
+
+        // For relative imports, resolve to an absolute-like path for parsing
+        let resolvedPath = importPath;
+        if (importPath.startsWith(".")) {
+          const fileDir = context.filename.replace(/\/[^/]+$/, "");
+          const parts = [...fileDir.split("/"), ...importPath.split("/")];
+          const resolved = [];
+          for (const p of parts) {
+            if (p === "..") resolved.pop();
+            else if (p !== ".") resolved.push(p);
+          }
+          resolvedPath = resolved.join("/");
+        }
+
+        const parsed = parseImportSource(resolvedPath, featureRoot);
+        if (!parsed) return;
+
+        const { featureDir, scope, layer } = parsed;
+        const expected = buildExpectedName(featureDir, scope, layer);
+        const actual = nsSpecifier.local.name;
+
+        if (actual !== expected) {
+          context.report({
+            node: nsSpecifier,
+            messageId: "mismatch",
+            data: { expected, actual },
+          });
+        }
+      },
+    };
+  },
+};

package/src/common/naming.mjs

@@ -4,10 +4,33 @@ import { checkFile } from "./plugins.mjs";
 
 /** Scope naming rules to the given feature root. */
 export function createNamingConfigs(featureRoot, prefixLibMapping) {
-  const prefixPattern = `@(${Object.keys(prefixLibMapping).join("|")})`;
-  const sharedPrefixPattern = `@(shared|${Object.keys(prefixLibMapping).join("|")})`;
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const prefixPattern = hasPrefixes ? `@(${prefixes.join("|")})` : null;
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
 
-  const configs = [
+  const servicePattern = prefixPattern
+    ? `${prefixPattern}.service`
+    : "*.service";
+  const repoPattern = prefixPattern ? `${prefixPattern}.repo` : "*.repo";
+  const actionPattern = prefixPattern
+    ? `${prefixPattern}.action`
+    : "*.action";
+
+  const configs = [];
+
+  configs.push({
+    name: "naming/namespace-import-name",
+    files: featuresGlob(featureRoot, "**/*.ts"),
+    plugins: { local: localPlugin },
+    rules: {
+      "local/namespace-import-name": ["error", { featureRoot }],
+    },
+  });
+
+  configs.push(
     {
       name: "naming/services",
       files: featuresGlob(featureRoot, "**/services/*.ts"),
@@ -16,30 +39,33 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${prefixPattern}.service` },
+          { "**/*.ts": servicePattern },
         ],
       },
     },
     {
-      name: "naming/services-shared",
-      files: featuresGlob(featureRoot, "shared/services/*.ts"),
+      name: "naming/repositories",
+      files: featuresGlob(featureRoot, "**/repositories/*.ts"),
+      ignores: featuresGlob(featureRoot, "shared/repositories/*.ts"),
       plugins: { "check-file": checkFile },
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${sharedPrefixPattern}.service` },
+          { "**/*.ts": repoPattern },
         ],
       },
     },
+  );
+
+  configs.push(
     {
-      name: "naming/repositories",
-      files: featuresGlob(featureRoot, "**/repositories/*.ts"),
-      ignores: featuresGlob(featureRoot, "shared/repositories/*.ts"),
+      name: "naming/services-shared",
+      files: featuresGlob(featureRoot, "shared/services/*.ts"),
       plugins: { "check-file": checkFile },
       rules: {
         "check-file/filename-naming-convention": [
           "error",
-          { "**/*.ts": `${prefixPattern}.repo` },
+          { "**/*.ts": `${sharedPrefixPattern}.service` },
         ],
       },
     },
@@ -54,7 +80,7 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
         ],
       },
     },
-  ];
+  );
 
   configs.push(
     {
@@ -153,18 +179,22 @@ export function createNamingConfigs(featureRoot, prefixLibMapping) {
         ],
       },
     },
-    {
-      name: "naming/actions",
-      files: featuresGlob(featureRoot, "**/actions/*.ts"),
-      ignores: featuresGlob(featureRoot, "shared/actions/*.ts"),
-      plugins: { "check-file": checkFile },
-      rules: {
-        "check-file/filename-naming-convention": [
-          "error",
-          { "**/*.ts": `${prefixPattern}.action` },
-        ],
-      },
-    },
+  );
+
+  configs.push({
+    name: "naming/actions",
+    files: featuresGlob(featureRoot, "**/actions/*.ts"),
+    ignores: featuresGlob(featureRoot, "shared/actions/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": actionPattern },
+      ],
+    },
+  });
+
+  configs.push(
     {
       name: "naming/actions-shared",
       files: featuresGlob(featureRoot, "shared/actions/*.ts"),

package/src/deno/imports.mjs

@@ -0,0 +1,57 @@
+const FUNCTIONS_ROOT = "supabase/functions";
+const FEATURE_ROOT = "supabase/functions/_features";
+
+/** Deno-specific import restriction rules. */
+export const denoImportsConfigs = [
+  {
+    name: "deno/lib-boundary",
+    files: [`${FUNCTIONS_ROOT}/**/*.ts`],
+    ignores: [
+      `${FUNCTIONS_ROOT}/_lib/**`,
+      `${FEATURE_ROOT}/**/repositories/**`,
+      `${FEATURE_ROOT}/**/types/**`,
+    ],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["*/_lib/*", "*/_lib/**"],
+              message:
+                "_lib/ can only be imported from repositories (lib-boundary violation)",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  {
+    name: "deno/commands-entry-point",
+    files: [`${FUNCTIONS_ROOT}/commands/**/*.ts`],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["**/services/*", "**/services"],
+              message:
+                "commands/ must not import services directly. Import from actions instead.",
+            },
+            {
+              group: ["**/repositories/*", "**/repositories"],
+              message:
+                "commands/ must not import repositories directly. Import from actions instead.",
+            },
+            {
+              group: ["*/_lib/*", "*/_lib/**"],
+              message:
+                "commands/ must not import _lib/ directly. Import from actions instead.",
+            },
+          ],
+        },
+      ],
+    },
+  },
+];

package/src/deno/index.mjs

@@ -1,8 +1,10 @@
 import { createCommonConfigs } from "../common/index.mjs";
+import { denoImportsConfigs } from "./imports.mjs";
+
+const FEATURE_ROOT = "supabase/functions/_features";
 
 /** Deno ESLint flat config entry point. */
 export const eslintConfig = [
-  ...createCommonConfigs("supabase/functions/features", {
-    banAliasImports: true,
-  }),
+  ...createCommonConfigs(FEATURE_ROOT, { banAliasImports: true }),
+  ...denoImportsConfigs,
 ];