@solid-stack/mason 1.0.34 → 1.0.36

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;
@@ -5655,45 +5648,108 @@ private ${m.name}(...) { ... }`
     }
   }
 }
+function resolveRegistryModuleError(modDir, modName) {
+  const errorsDir = path26__default.default.join(modDir, "errors");
+  if (!fs17__default.default.existsSync(errorsDir) || !fs17__default.default.statSync(errorsDir).isDirectory()) {
+    return { errorsDir, hasErrorsDir: false };
+  }
+  const entries = fs17__default.default.readdirSync(errorsDir);
+  const errorFiles = entries.filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+  const nameNormalized = modName.toLowerCase().replace(/[-_]/g, "");
+  const singularNormalized = toSingular(modName).toLowerCase().replace(/[-_]/g, "");
+  let baseErrorFileName = errorFiles.find((f) => {
+    const baseNoExt = f.replace(/\.(ts|js)$/, "").toLowerCase().replace(/[-_]/g, "");
+    return baseNoExt === `${nameNormalized}error` || baseNoExt === `${singularNormalized}error` || baseNoExt === `${nameNormalized}errors` || baseNoExt === `${singularNormalized}errors`;
+  });
+  if (!baseErrorFileName) {
+    return { errorsDir, hasErrorsDir: true };
+  }
+  const baseErrorFileAbs = path26__default.default.join(errorsDir, baseErrorFileName);
+  const content = fs17__default.default.readFileSync(baseErrorFileAbs, "utf-8");
+  const classRegex = /(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Za-z0-9_]+)(?:<[^>]+>)?(?:\s+extends\s+([A-Za-z0-9_]+))?/g;
+  let match;
+  const classes = [];
+  while ((match = classRegex.exec(content)) !== null) {
+    classes.push({
+      name: match[1],
+      extendsName: match[2],
+      raw: match[0]
+    });
+  }
+  const expectedNames = [
+    `${toPascalCase(modName)}Error`,
+    `${toPascalCase(toSingular(modName))}Error`,
+    `${toPascalCase(modName)}Errors`,
+    `${toPascalCase(toSingular(modName))}Errors`
+  ].map((n) => n.toLowerCase());
+  const targetClass = classes.find((c) => expectedNames.includes(c.name.toLowerCase())) || classes.find((c) => c.raw.includes("export")) || classes[0];
+  return {
+    errorsDir,
+    hasErrorsDir: true,
+    baseErrorFileAbs,
+    baseErrorClassName: targetClass ? targetClass.name : void 0,
+    baseErrorExtendsName: targetClass ? targetClass.extendsName : void 0,
+    baseErrorRawClassCode: targetClass ? targetClass.raw : void 0
+  };
+}
 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 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/'.`,
-      [],
-      true
-    );
+  const effectiveMode = options.mode || getEffectiveMode(projectRoot, options.registry !== void 0 ? { registry: options.registry } : void 0);
+  const isRegistryMode = effectiveMode === "registry";
+  const { featuresBase, sharedBase, errorsBase, baseErrorAbs } = resolveLintEnvironment(projectRoot);
+  if (!isRegistryMode) {
+    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 architecture must contain 'features/', 'shared/', and 'errors/'.`,
+        [],
+        true
+      );
+    }
+    if (!fs17__default.default.existsSync(baseErrorAbs)) {
+      throw new DependencyRuleError(
+        `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
+      );
+    }
+  } else {
+    if (!fs17__default.default.existsSync(featuresBase) && !fs17__default.default.existsSync(sharedBase)) {
+      throw new DependencyRuleError(
+        `Project Structure Violation: Missing required foundational directories: features/ or shared/. A registry must contain 'features/' or 'shared/'.`,
+        [],
+        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.`,
-      [],
-      true
+  let baseErrorClassName = "AppError";
+  if (!isRegistryMode && fs17__default.default.existsSync(baseErrorAbs)) {
+    const baseErrorContent = fs17__default.default.readFileSync(baseErrorAbs, "utf-8");
+    const baseClassMatch = baseErrorContent.match(
+      /(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Za-z0-9_]+)/
     );
+    baseErrorClassName = baseClassMatch ? baseClassMatch[1] : "AppError";
   }
-  const baseErrorContent = fs17__default.default.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(featuresBase, [sharedBase, errorsBase]);
   const sharedModules = discoverAllShared(sharedBase, [featuresBase, errorsBase]);
-  const errorModule = { name: "global-errors", dir: errorsBase, type: "error" };
   const allModules = [
     ...features.map((f) => ({ ...f, type: "feature" })),
-    ...sharedModules.map((s) => ({ ...s, type: "shared" })),
-    errorModule
+    ...sharedModules.map((s) => ({ ...s, type: "shared" }))
   ];
+  if (!isRegistryMode) {
+    const errorModule = { name: "global-errors", dir: errorsBase, type: "error" };
+    allModules.push(errorModule);
+  } else if (fs17__default.default.existsSync(errorsBase)) {
+    const errorFiles = scanDirFiles(errorsBase, projectRoot);
+    if (errorFiles.length > 0) {
+      allModules.push({ name: "global-errors", dir: errorsBase, type: "error" });
+    }
+  }
   const graph = new FeatureDependencyGraph();
   const allViolations = [];
   const results = [];
@@ -5727,6 +5783,77 @@ Code: ${v.code}`;
   }
   for (const mod of allModules) {
     const modResult = results.find((r) => r.featureName === mod.name);
+    let modBaseErrorClass = baseErrorClassName;
+    let modBaseErrorAbs = !isRegistryMode ? baseErrorAbs : void 0;
+    if (isRegistryMode && (mod.type === "feature" || mod.type === "shared")) {
+      const errorInfo = resolveRegistryModuleError(mod.dir, mod.name);
+      if (!errorInfo.hasErrorsDir) {
+        addViolation({
+          feature: mod.name,
+          layer: "domain",
+          file: mod.dir,
+          relativePath: path26__default.default.relative(projectRoot, errorInfo.errorsDir).replace(/\\/g, "/"),
+          line: 1,
+          category: "Project Structure Violation",
+          code: `Missing errors/ directory in registry ${mod.type} '${mod.name}'`,
+          ruleId: "REG_ERRORS_DIR_REQUIRED",
+          severity: "error",
+          advice: `Registry ${mod.type} '${mod.name}' must implement its own 'errors/' directory at '${path26__default.default.relative(projectRoot, errorInfo.errorsDir).replace(/\\/g, "/")}'.`,
+          fixExample: {
+            bad: "// Missing errors directory",
+            good: `mkdir -p ${path26__default.default.relative(projectRoot, errorInfo.errorsDir).replace(/\\/g, "/")}`
+          }
+        });
+      } else if (!errorInfo.baseErrorFileAbs) {
+        const expectedFileName = `${toPascalCase(mod.name)}Error.ts`;
+        const expectedRel = path26__default.default.relative(projectRoot, path26__default.default.join(errorInfo.errorsDir, expectedFileName)).replace(/\\/g, "/");
+        addViolation({
+          feature: mod.name,
+          layer: "domain",
+          file: errorInfo.errorsDir,
+          relativePath: expectedRel,
+          line: 1,
+          category: "Project Structure Violation",
+          code: `Missing base error file in '${mod.name}/errors'`,
+          ruleId: "REG_BASE_ERROR_REQUIRED",
+          severity: "error",
+          advice: `Registry ${mod.type} '${mod.name}' must have a base error file at '${expectedRel}'.`,
+          fixExample: {
+            bad: "// Missing base error file",
+            good: `export class ${toPascalCase(mod.name)}Error extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}`
+          }
+        });
+      } else {
+        modBaseErrorAbs = errorInfo.baseErrorFileAbs;
+        modBaseErrorClass = errorInfo.baseErrorClassName || `${toPascalCase(mod.name)}Error`;
+        if (!errorInfo.baseErrorClassName || errorInfo.baseErrorExtendsName !== "Error") {
+          addViolation({
+            feature: mod.name,
+            layer: "domain",
+            file: errorInfo.baseErrorFileAbs,
+            relativePath: path26__default.default.relative(projectRoot, errorInfo.baseErrorFileAbs).replace(/\\/g, "/"),
+            line: 1,
+            category: "Error Inheritance Violation",
+            code: errorInfo.baseErrorRawClassCode || `class ${modBaseErrorClass}`,
+            ruleId: "REG_BASE_ERROR_MUST_EXTEND_ERROR",
+            severity: "error",
+            advice: `Registry ${mod.type} base error class '${modBaseErrorClass}' in '${mod.name}' must extend native 'Error'.`,
+            fixExample: {
+              bad: errorInfo.baseErrorRawClassCode || `class ${modBaseErrorClass}`,
+              good: `export class ${modBaseErrorClass} extends Error {
+  constructor(message: string) {
+    super(message);
+  }
+}`
+            }
+          });
+        }
+      }
+    }
     const allFiles = scanDirFiles(mod.dir, projectRoot);
     modResult.scannedFilesCount = allFiles.length;
     for (const file of allFiles) {
@@ -5754,15 +5881,15 @@ 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: isRegistryMode ? `Throwing plain 'Error' is prohibited in registry ${mod.type} '${mod.name}'. You must throw '${modBaseErrorClass}' or a class that inherits from it.` : `Throwing plain 'Error' is prohibited. You must throw '${modBaseErrorClass}' or a custom error class that inherits from it.`,
           fixExample: {
             bad: lineCode,
-            good: `throw new ${baseErrorClassName}("Something went wrong");`
+            good: `throw new ${modBaseErrorClass}("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 = path26__default.default.resolve(file) === path26__default.default.resolve(baseErrorAbs);
+      const isBaseErrorFile = modBaseErrorAbs ? path26__default.default.resolve(file) === path26__default.default.resolve(modBaseErrorAbs) : !isRegistryMode && path26__default.default.resolve(file) === path26__default.default.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;
@@ -5784,10 +5911,10 @@ 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: isRegistryMode ? `Error class '${className}' in registry ${mod.type} '${mod.name}' must extend '${modBaseErrorClass}'.` : `Error class '${className}' must extend '${modBaseErrorClass}'.`,
               fixExample: {
                 bad: lineCode,
-                good: `export class ${className} extends ${baseErrorClassName} { ... }`
+                good: `export class ${className} extends ${modBaseErrorClass} { ... }`
               }
             });
           } else if (extendsName === "Error") {
@@ -5801,10 +5928,10 @@ 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: isRegistryMode ? `Error class '${className}' extends native 'Error'. In registry ${mod.type} '${mod.name}', it must extend your base error class ('${modBaseErrorClass}').` : `Error class '${className}' extends native 'Error'. It must extend your configured base error class ('${modBaseErrorClass}').`,
               fixExample: {
                 bad: lineCode,
-                good: `export class ${className} extends ${baseErrorClassName} { ... }`
+                good: `export class ${className} extends ${modBaseErrorClass} { ... }`
               }
             });
           }
@@ -6564,7 +6691,9 @@ async function handleLint(flags = {}) {
     targetDir: flags.targetDir || flags.target,
     projectRoot: flags.projectRoot,
     fixHint: flags.fixHint !== false,
-    throwOnError: false
+    throwOnError: false,
+    mode: flags.mode || (flags.registry ? "registry" : void 0),
+    registry: Boolean(flags.registry)
   };
   try {
     const summary = lintCodebase(options);