@solid-stack/mason 1.0.32 → 1.0.33

package/dist/bin.js

@@ -189,6 +189,16 @@ function getConfiguredSharedDir(projectRoot, flags) {
   }
   return path2.join(projectRoot, "shared");
 }
+function loadLintConfig(projectRoot) {
+  const configPath = path2.join(projectRoot, "mason-lint.config.json");
+  if (fs14.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs14.readFileSync(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  return { baseErrorPath: "src/errors/AppError.ts" };
+}
 
 // src/utils/project.ts
 function findProjectRoot(startDir = process.cwd()) {
@@ -4908,6 +4918,15 @@ function classifyFile(fullPath, projectRoot) {
     }
     return { moduleType: "shared", moduleName, feature: moduleName, layer };
   }
+  const errorMatch = rel.match(/(?:^|\/)(?:src\/)?errors(?:\/(.*))?$/);
+  if (errorMatch) {
+    return {
+      moduleType: "error",
+      moduleName: "global-errors",
+      feature: "global-errors",
+      layer: "domain"
+    };
+  }
   return {};
 }
 function classifyTarget(specifier, sourceFileAbs, projectRoot) {
@@ -4933,15 +4952,28 @@ function classifyTarget(specifier, sourceFileAbs, projectRoot) {
     resolvedRel = specifier.replace(/^[@~]\//, "src/");
   } else if (specifier === "@configs" || specifier.startsWith("@configs/")) {
     resolvedRel = "src/" + specifier.slice(1);
+  } else if (specifier.startsWith("@/errors/") || specifier.startsWith("~/errors/") || specifier === "@/errors" || specifier === "~/errors") {
+    resolvedRel = specifier.replace(/^[@~]\//, "src/");
+  } else if (specifier === "@errors" || specifier.startsWith("@errors/")) {
+    resolvedRel = "src/" + specifier.slice(1);
   } else if (specifier.startsWith("@/") || specifier.startsWith("~/")) {
     resolvedRel = "src/" + specifier.slice(2);
-  } else if (specifier.startsWith("features/") || specifier.startsWith("shared/") || specifier.startsWith("configs/") || specifier === "configs") {
+  } else if (specifier.startsWith("features/") || specifier.startsWith("shared/") || specifier.startsWith("configs/") || specifier === "configs" || specifier.startsWith("errors/") || specifier === "errors") {
     resolvedRel = specifier;
   }
   if (!resolvedRel) {
     return { isExternal: true, isDiFramework: false };
   }
   const isGlobalConfig = resolvedRel.startsWith("src/configs/") || resolvedRel === "src/configs" || resolvedRel.startsWith("configs/") || resolvedRel === "configs";
+  const isGlobalError = resolvedRel.startsWith("src/errors/") || resolvedRel === "src/errors" || resolvedRel.startsWith("errors/") || resolvedRel === "errors";
+  if (isGlobalError) {
+    return {
+      isExternal: false,
+      isDiFramework: false,
+      isGlobalError: true,
+      isTargetError: true
+    };
+  }
   const featMatch = resolvedRel.match(/(?:^|\/)(?:src\/)?features\/([^/]+)\/([^/]+)(?:\/(.*))?$/);
   if (featMatch && featMatch[1] && featMatch[2]) {
     const targetFeature = featMatch[1];
@@ -5482,11 +5514,45 @@ function lintCodebase(options = {}) {
   const startTime = Date.now();
   const projectRoot = options.projectRoot || findProjectRoot(options.targetDir || process.cwd());
   const failFast = !options.complete;
+  const lintConfig = loadLintConfig(projectRoot);
+  const baseErrorRelative = lintConfig.baseErrorPath || "src/errors/AppError.ts";
+  const baseErrorAbs = path2.resolve(projectRoot, baseErrorRelative);
+  const featuresBase = resolveFeaturesDir(projectRoot);
+  const sharedBase = resolveSharedDir(projectRoot);
+  let errorsBase = path2.join(projectRoot, "src/errors");
+  if (!fs14.existsSync(errorsBase) && fs14.existsSync(path2.join(projectRoot, "errors"))) {
+    errorsBase = path2.join(projectRoot, "errors");
+  }
+  const missingFoundations = [];
+  if (!fs14.existsSync(featuresBase)) missingFoundations.push("features/");
+  if (!fs14.existsSync(sharedBase)) missingFoundations.push("shared/");
+  if (!fs14.existsSync(errorsBase)) missingFoundations.push("errors/");
+  if (missingFoundations.length > 0) {
+    throw new DependencyRuleError(
+      `Project Structure Violation: Missing required foundational directories: ${missingFoundations.join(", ")}. Every project must contain 'features/', 'shared/', and 'errors/'.`,
+      [],
+      true
+    );
+  }
+  if (!fs14.existsSync(baseErrorAbs)) {
+    throw new DependencyRuleError(
+      `Project Structure Violation: Base error class not found at '${baseErrorRelative}'. Create this file or update 'baseErrorPath' in mason-lint.config.json.`,
+      [],
+      true
+    );
+  }
+  const baseErrorContent = fs14.readFileSync(baseErrorAbs, "utf-8");
+  const baseClassMatch = baseErrorContent.match(
+    /(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Za-z0-9_]+)/
+  );
+  const baseErrorClassName = baseClassMatch ? baseClassMatch[1] : "AppError";
   const features = discoverAllFeatures(projectRoot);
   const sharedModules = discoverAllShared(projectRoot);
+  const errorModule = { name: "global-errors", dir: errorsBase, type: "error" };
   const allModules = [
     ...features.map((f) => ({ ...f, type: "feature" })),
-    ...sharedModules.map((s) => ({ ...s, type: "shared" }))
+    ...sharedModules.map((s) => ({ ...s, type: "shared" })),
+    errorModule
   ];
   const graph = new FeatureDependencyGraph();
   const allViolations = [];
@@ -5516,7 +5582,7 @@ Code: ${v.code}`;
       scannedFilesCount: 0,
       passed: true,
       violations: [],
-      layersChecked: mod.type === "feature" ? ["domain", "useCases", "services", "infrastructure", "presentation"] : ["domain", "ports", "infrastructure", "root"]
+      layersChecked: mod.type === "feature" ? ["domain", "useCases", "services", "infrastructure", "presentation"] : mod.type === "shared" ? ["domain", "ports", "infrastructure", "root"] : ["domain"]
     });
   }
   for (const mod of allModules) {
@@ -5531,6 +5597,121 @@ Code: ${v.code}`;
       const statements = extractImportStatements(content);
       const baseName = path2.basename(file);
       const isBarrel = baseName === "index.ts" || baseName === "index.js";
+      const throwErrorRegex = /\bthrow\s+(?:new\s+)?Error\s*\(/g;
+      let throwMatch;
+      while ((throwMatch = throwErrorRegex.exec(content)) !== null) {
+        const charIndex = throwMatch.index;
+        const lineNum = content.substring(0, charIndex).split("\n").length;
+        const lineCode = content.split(/\r?\n/)[lineNum - 1]?.trim() || throwMatch[0];
+        if (lineCode.startsWith("//")) continue;
+        addViolation({
+          feature: moduleName,
+          layer,
+          file,
+          relativePath: relPath,
+          line: lineNum,
+          category: "Plain Error Throw Violation",
+          code: lineCode,
+          ruleId: "E3_PLAIN_ERROR_THROW",
+          severity: "error",
+          advice: `Throwing plain 'Error' is prohibited. You must throw '${baseErrorClassName}' or a domain-specific error class that inherits from it.`,
+          fixExample: {
+            bad: lineCode,
+            good: `throw new ${baseErrorClassName}("Something went wrong");`
+          }
+        });
+      }
+      const isErrorFile = relPath.includes("/errors/") || relPath.startsWith("errors/") || relPath.startsWith("src/errors/") || moduleType === "error" || baseName.endsWith("Error.ts") || baseName.endsWith("Errors.ts") || baseName.endsWith("Error.js") || baseName.endsWith("Errors.js");
+      const isBaseErrorFile = path2.resolve(file) === path2.resolve(baseErrorAbs);
+      if (isErrorFile && !isBaseErrorFile) {
+        const classRegex = /(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Za-z0-9_]+)(?:<[^>]+>)?(?:\s+extends\s+([A-Za-z0-9_]+))?/g;
+        let classMatch;
+        while ((classMatch = classRegex.exec(content)) !== null) {
+          const className = classMatch[1];
+          const extendsName = classMatch[2];
+          const charIndex = classMatch.index;
+          const lineNum = content.substring(0, charIndex).split("\n").length;
+          const lineCode = content.split(/\r?\n/)[lineNum - 1]?.trim() || classMatch[0];
+          if (lineCode.startsWith("//")) continue;
+          if (!extendsName) {
+            addViolation({
+              feature: moduleName,
+              layer,
+              file,
+              relativePath: relPath,
+              line: lineNum,
+              category: "Error Inheritance Violation",
+              code: lineCode,
+              ruleId: "E4_MISSING_INHERITANCE",
+              severity: "error",
+              advice: `Error class '${className}' must extend '${baseErrorClassName}' (or another class that derives from it).`,
+              fixExample: {
+                bad: lineCode,
+                good: `export class ${className} extends ${baseErrorClassName} { ... }`
+              }
+            });
+          } else if (extendsName === "Error") {
+            addViolation({
+              feature: moduleName,
+              layer,
+              file,
+              relativePath: relPath,
+              line: lineNum,
+              category: "Error Inheritance Violation",
+              code: lineCode,
+              ruleId: "E5_NATIVE_ERROR_INHERITANCE",
+              severity: "error",
+              advice: `Error class '${className}' extends the native 'Error'. It must extend your base error class ('${baseErrorClassName}').`,
+              fixExample: {
+                bad: lineCode,
+                good: `export class ${className} extends ${baseErrorClassName} { ... }`
+              }
+            });
+          }
+        }
+      }
+      if (moduleType === "error") {
+        for (const stmt of statements) {
+          const target = classifyTarget(stmt.specifier, file, projectRoot);
+          if (target.targetFeature) {
+            addViolation({
+              feature: "global-errors",
+              layer: "domain",
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Global Error Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "E1_FEATURE_DEPENDENCY",
+              severity: "error",
+              advice: `Global errors must not depend on features ('${target.targetFeature}'). Global errors represent pure domain or system states.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Global errors must not reference specific features. Keep error types pure."
+              }
+            });
+          }
+          if (target.targetSharedModule && !target.isSharedDomain) {
+            addViolation({
+              feature: "global-errors",
+              layer: "domain",
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Global Error Purity Violation",
+              code: stmt.rawCode,
+              ruleId: "E2_SHARED_NON_DOMAIN",
+              severity: "error",
+              advice: `Global errors can only depend on shared domain elements (e.g., value objects). They cannot depend on shared ports or infrastructure.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Depend only on pure domain types from shared modules."
+              }
+            });
+          }
+        }
+        continue;
+      }
       if (moduleType === "shared") {
         if (layer === "domain") {
           const lines = content.split(/\r?\n/);