@solid-stack/mason 1.0.34 → 1.0.35

package/dist/bin.cjs

@@ -218,37 +218,6 @@ function getConfiguredSharedDir(projectRoot, flags) {
   }
   return path26__default.default.join(projectRoot, "shared");
 }
-function loadLintConfig(projectRoot) {
-  const configPath = path26__default.default.join(projectRoot, "mason-lint.config.json");
-  if (fs17__default.default.existsSync(configPath)) {
-    try {
-      return JSON.parse(fs17__default.default.readFileSync(configPath, "utf-8"));
-    } catch {
-    }
-  }
-  return {};
-}
-function getResolvedLintPaths(projectRoot, config) {
-  const masonConfig = loadMasonConfig(projectRoot);
-  const configuredFeatures = config.paths?.features ?? masonConfig?.paths?.features;
-  const configuredShared = config.paths?.shared ?? masonConfig?.paths?.shared;
-  const configuredErrors = config.paths?.errors;
-  const resolveBase = (configuredPath, defaultSrc, defaultRoot) => {
-    if (configuredPath !== void 0) {
-      return path26__default.default.resolve(projectRoot, configuredPath);
-    }
-    const srcPath = path26__default.default.join(projectRoot, defaultSrc);
-    if (fs17__default.default.existsSync(srcPath)) return srcPath;
-    const rootPath = path26__default.default.join(projectRoot, defaultRoot);
-    if (fs17__default.default.existsSync(rootPath)) return rootPath;
-    return srcPath;
-  };
-  return {
-    featuresBase: resolveBase(configuredFeatures, "src/features", "features"),
-    sharedBase: resolveBase(configuredShared, "src/shared", "shared"),
-    errorsBase: resolveBase(configuredErrors, "src/errors", "errors")
-  };
-}
 
 // src/utils/project.ts
 function findProjectRoot(startDir = process.cwd()) {
@@ -4934,19 +4903,43 @@ function scanDirFiles(dir, projectRoot) {
   }
   return files;
 }
+function resolveLintEnvironment(projectRoot) {
+  const config = loadMasonConfig(projectRoot);
+  const resolveDir = (configured, defaultSrc, defaultRoot) => {
+    if (configured !== void 0) {
+      return path26__default.default.resolve(projectRoot, configured);
+    }
+    const srcPath = path26__default.default.join(projectRoot, defaultSrc);
+    if (fs17__default.default.existsSync(srcPath)) return srcPath;
+    const rootPath = path26__default.default.join(projectRoot, defaultRoot);
+    if (fs17__default.default.existsSync(rootPath)) return rootPath;
+    return srcPath;
+  };
+  const featuresBase = resolveDir(config?.paths?.features, "src/features", "features");
+  const sharedBase = resolveDir(config?.paths?.shared, "src/shared", "shared");
+  const errorsBase = resolveDir(config?.paths?.errors, "src/errors", "errors");
+  const defaultBaseErrorRelative = config?.paths?.errors ? path26__default.default.join(config.paths.errors, "AppError.ts") : fs17__default.default.existsSync(path26__default.default.join(projectRoot, "src/errors")) ? "src/errors/AppError.ts" : fs17__default.default.existsSync(path26__default.default.join(projectRoot, "errors")) ? "errors/AppError.ts" : "src/errors/AppError.ts";
+  const baseErrorAbs = path26__default.default.resolve(
+    projectRoot,
+    config?.paths?.baseError || defaultBaseErrorRelative
+  );
+  return { featuresBase, sharedBase, errorsBase, baseErrorAbs };
+}
 function classifyFile(fullPathAbs, featuresBaseAbs, sharedBaseAbs, errorsBaseAbs) {
   if (!sharedBaseAbs || !errorsBaseAbs) {
-    const paths = getResolvedLintPaths(featuresBaseAbs, loadLintConfig(featuresBaseAbs));
-    featuresBaseAbs = paths.featuresBase;
-    sharedBaseAbs = paths.sharedBase;
-    errorsBaseAbs = paths.errorsBase;
+    const env = resolveLintEnvironment(featuresBaseAbs);
+    featuresBaseAbs = env.featuresBase;
+    sharedBaseAbs = env.sharedBase;
+    errorsBaseAbs = env.errorsBase;
   }
   const normFullPath = path26__default.default.resolve(fullPathAbs);
   const normErrorsBase = path26__default.default.resolve(errorsBaseAbs);
   const normSharedBase = path26__default.default.resolve(sharedBaseAbs);
   const normFeaturesBase = path26__default.default.resolve(featuresBaseAbs);
-  const relErrors = path26__default.default.relative(normErrorsBase, normFullPath).replace(/\\/g, "/");
-  if (!relErrors.startsWith("..") && !path26__default.default.isAbsolute(relErrors)) {
+  const isUnder = (base, target) => {
+    return target === base || target.startsWith(base + path26__default.default.sep);
+  };
+  if (isUnder(normErrorsBase, normFullPath)) {
     return {
       moduleType: "error",
       moduleName: "global-errors",
@@ -4954,26 +4947,26 @@ function classifyFile(fullPathAbs, featuresBaseAbs, sharedBaseAbs, errorsBaseAbs
       layer: "domain"
     };
   }
-  const relShared = path26__default.default.relative(normSharedBase, normFullPath).replace(/\\/g, "/");
-  if (!relShared.startsWith("..") && !path26__default.default.isAbsolute(relShared)) {
-    const parts = relShared.split("/").filter(Boolean);
+  if (isUnder(normSharedBase, normFullPath)) {
+    const rel = path26__default.default.relative(normSharedBase, normFullPath).replace(/\\/g, "/");
+    const parts = rel.split("/").filter(Boolean);
     if (parts.length >= 1) {
       const moduleName = parts[0];
-      const rest = parts.slice(1).join("/");
+      const subfolder = parts[1];
       let layer = "root";
-      if (rest.startsWith("domain/") || rest === "domain" || rest.startsWith("errors/") || rest === "errors") {
+      if (subfolder === "domain" || subfolder === "errors") {
         layer = "domain";
-      } else if (rest.startsWith("ports/") || rest === "ports") {
+      } else if (subfolder === "ports") {
         layer = "ports";
-      } else if (rest.startsWith("infrastructure/") || rest === "infrastructure") {
+      } else if (subfolder === "infrastructure") {
         layer = "infrastructure";
       }
       return { moduleType: "shared", moduleName, feature: moduleName, layer };
     }
   }
-  const relFeatures = path26__default.default.relative(normFeaturesBase, normFullPath).replace(/\\/g, "/");
-  if (!relFeatures.startsWith("..") && !path26__default.default.isAbsolute(relFeatures)) {
-    const parts = relFeatures.split("/").filter(Boolean);
+  if (isUnder(normFeaturesBase, normFullPath)) {
+    const rel = path26__default.default.relative(normFeaturesBase, normFullPath).replace(/\\/g, "/");
+    const parts = rel.split("/").filter(Boolean);
     if (parts.length >= 2) {
       const moduleName = parts[0];
       const subfolder = parts[1];
@@ -4986,7 +4979,7 @@ function classifyFile(fullPathAbs, featuresBaseAbs, sharedBaseAbs, errorsBaseAbs
         layer = "services";
       } else if (subfolder === "infrastructure") {
         layer = "infrastructure";
-      } else if (subfolder === "pxExpress" || subfolder === "presentation" || subfolder === "handlers" || subfolder.startsWith("px")) {
+      } else if (subfolder.startsWith("px") || subfolder === "presentation" || subfolder === "handlers" || subfolder === "transformers") {
         layer = "presentation";
       }
       return { moduleType: "feature", moduleName, feature: moduleName, layer };
@@ -5015,10 +5008,10 @@ function classifyTarget(specifier, sourceFileAbs, projectRoot, featuresBaseAbs,
     return { isExternal: true, isDiFramework: false };
   }
   if (!featuresBaseAbs || !sharedBaseAbs || !errorsBaseAbs) {
-    const paths = getResolvedLintPaths(projectRoot, loadLintConfig(projectRoot));
-    featuresBaseAbs = featuresBaseAbs || paths.featuresBase;
-    sharedBaseAbs = sharedBaseAbs || paths.sharedBase;
-    errorsBaseAbs = errorsBaseAbs || paths.errorsBase;
+    const env = resolveLintEnvironment(projectRoot);
+    featuresBaseAbs = featuresBaseAbs || env.featuresBase;
+    sharedBaseAbs = sharedBaseAbs || env.sharedBase;
+    errorsBaseAbs = errorsBaseAbs || env.errorsBase;
   }
   const isGlobalConfig = specifier === "@configs" || specifier.startsWith("@configs/") || specifier === "@/configs" || specifier.startsWith("@/configs/") || specifier === "~/configs" || specifier.startsWith("~/configs/") || specifier === "configs" || specifier.startsWith("configs/");
   let targetAbs = null;
@@ -5659,24 +5652,21 @@ 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 { featuresBase, sharedBase, errorsBase } = getResolvedLintPaths(projectRoot, lintConfig);
+  const { featuresBase, sharedBase, errorsBase, baseErrorAbs } = resolveLintEnvironment(projectRoot);
   const missingFoundations = [];
   if (!fs17__default.default.existsSync(featuresBase)) missingFoundations.push("features/");
   if (!fs17__default.default.existsSync(sharedBase)) missingFoundations.push("shared/");
   if (!fs17__default.default.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/'.`,
+      `Project Structure Violation: Missing required foundational directories: ${missingFoundations.join(", ")}. Every architecture must contain 'features/', 'shared/', and 'errors/'.`,
       [],
       true
     );
   }
-  const baseErrorRelative = lintConfig.baseErrorPath || path26__default.default.relative(projectRoot, path26__default.default.join(errorsBase, "AppError.ts")).replace(/\\/g, "/");
-  const baseErrorAbs = path26__default.default.resolve(projectRoot, baseErrorRelative);
   if (!fs17__default.default.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.`,
+      `Project Structure Violation: Base error class not found at '${path26__default.default.relative(projectRoot, baseErrorAbs).replace(/\\/g, "/")}'. Configure paths.baseError in mason.config.json.`,
       [],
       true
     );
@@ -5754,7 +5744,7 @@ Code: ${v.code}`;
           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.`,
+          advice: `Throwing plain 'Error' is prohibited. You must throw '${baseErrorClassName}' or a custom error class that inherits from it.`,
           fixExample: {
             bad: lineCode,
             good: `throw new ${baseErrorClassName}("Something went wrong");`
@@ -5784,7 +5774,7 @@ Code: ${v.code}`;
               code: lineCode,
               ruleId: "E4_MISSING_INHERITANCE",
               severity: "error",
-              advice: `Error class '${className}' must extend '${baseErrorClassName}' (or another class that derives from it).`,
+              advice: `Error class '${className}' must extend '${baseErrorClassName}'.`,
               fixExample: {
                 bad: lineCode,
                 good: `export class ${className} extends ${baseErrorClassName} { ... }`
@@ -5801,7 +5791,7 @@ Code: ${v.code}`;
               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}').`,
+              advice: `Error class '${className}' extends native 'Error'. It must extend your configured base error class ('${baseErrorClassName}').`,
               fixExample: {
                 bad: lineCode,
                 good: `export class ${className} extends ${baseErrorClassName} { ... }`