@solid-stack/mason 1.0.35 → 1.0.36

package/dist/bin.cjs

@@ -5648,42 +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 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);
-  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 (!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
+      );
+    }
   }
-  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
+  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 = [];
@@ -5717,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) {
@@ -5744,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 custom 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;
@@ -5774,10 +5911,10 @@ Code: ${v.code}`;
               code: lineCode,
               ruleId: "E4_MISSING_INHERITANCE",
               severity: "error",
-              advice: `Error class '${className}' must extend '${baseErrorClassName}'.`,
+              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") {
@@ -5791,10 +5928,10 @@ Code: ${v.code}`;
               code: lineCode,
               ruleId: "E5_NATIVE_ERROR_INHERITANCE",
               severity: "error",
-              advice: `Error class '${className}' extends native 'Error'. It must extend your configured 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} { ... }`
               }
             });
           }
@@ -6554,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);