@solid-stack/mason 1.0.31 → 1.0.32

package/dist/index.js

@@ -4886,22 +4886,38 @@ function scanDirFiles(dir, projectRoot) {
 function classifyFile(fullPath, projectRoot) {
   const rel = path2.relative(projectRoot, fullPath).replace(/\\/g, "/");
   const featureMatch = rel.match(/(?:^|\/)(?:src\/)?features\/([^/]+)\/([^/]+)(?:\/.*)?$/);
-  if (!featureMatch || !featureMatch[1] || !featureMatch[2]) return {};
-  const feature = featureMatch[1];
-  const subfolder = featureMatch[2];
-  let layer;
-  if (subfolder === "domain" || subfolder === "errors") {
-    layer = "domain";
-  } else if (subfolder === "useCases" || subfolder === "usecases") {
-    layer = "useCases";
-  } else if (subfolder === "services") {
-    layer = "services";
-  } else if (subfolder === "infrastructure") {
-    layer = "infrastructure";
-  } else if (subfolder === "pxExpress" || subfolder === "presentation" || subfolder === "handlers" || subfolder.startsWith("px")) {
-    layer = "presentation";
-  }
-  return { feature, layer };
+  if (featureMatch && featureMatch[1] && featureMatch[2]) {
+    const feature = featureMatch[1];
+    const subfolder = featureMatch[2];
+    let layer;
+    if (subfolder === "domain" || subfolder === "errors") {
+      layer = "domain";
+    } else if (subfolder === "useCases" || subfolder === "usecases") {
+      layer = "useCases";
+    } else if (subfolder === "services") {
+      layer = "services";
+    } else if (subfolder === "infrastructure") {
+      layer = "infrastructure";
+    } else if (subfolder === "pxExpress" || subfolder === "presentation" || subfolder === "handlers" || subfolder.startsWith("px")) {
+      layer = "presentation";
+    }
+    return { moduleType: "feature", moduleName: feature, feature, layer };
+  }
+  const sharedMatch = rel.match(/(?:^|\/)(?:src\/)?shared\/([^/]+)(?:\/(.*))?$/);
+  if (sharedMatch && sharedMatch[1]) {
+    const moduleName = sharedMatch[1];
+    const rest = sharedMatch[2] || "";
+    let layer = "root";
+    if (rest.startsWith("domain/") || rest === "domain" || rest.startsWith("errors/") || rest === "errors") {
+      layer = "domain";
+    } else if (rest.startsWith("ports/") || rest === "ports") {
+      layer = "ports";
+    } else if (rest.startsWith("infrastructure/") || rest === "infrastructure") {
+      layer = "infrastructure";
+    }
+    return { moduleType: "shared", moduleName, feature: moduleName, layer };
+  }
+  return {};
 }
 function classifyTarget(specifier, sourceFileAbs, projectRoot) {
   if (specifier === "@solid-stack/di" || specifier.startsWith("@solid-stack/di/")) {
@@ -4956,6 +4972,7 @@ function classifyTarget(specifier, sourceFileAbs, projectRoot) {
     const targetFileName = basePart.replace(/\.(js|ts|mjs|cjs)$/, "");
     const isTargetPort = /^I[A-Z]/.test(targetFileName);
     const isTargetRepo = isTargetPort && targetFileName.includes("Repo");
+    const isTargetError = targetSubfolder === "errors" || rest.startsWith("errors/") || rest.includes("/errors/") || targetFileName.endsWith("Error") || targetFileName.endsWith("Errors");
     return {
       isExternal: false,
       isDiFramework: false,
@@ -4964,7 +4981,8 @@ function classifyTarget(specifier, sourceFileAbs, projectRoot) {
       targetSubfolder,
       targetFileName,
       isTargetPort,
-      isTargetRepo
+      isTargetRepo,
+      isTargetError
     };
   }
   const sharedMatch = resolvedRel.match(/(?:^|\/)(?:src\/)?shared\/([^/]+)(?:\/(.*))?$/);
@@ -4990,17 +5008,34 @@ function classifyTarget(specifier, sourceFileAbs, projectRoot) {
 function extractImportStatements(content) {
   const statements = [];
   const lines = content.split(/\r?\n/);
-  const regex = /(?:import\s+(?:type\s+)?(?:[\s\w*$,{}]+\s+from\s+)?|export\s+(?:type\s+)?(?:[\s\w*$,{}]+\s+from\s+)?|import\s*\(|require\s*\()\s*["']([^"']+)["']/g;
+  const regex = /(?:import\s+(type\s+)?(?:([\s\w*$,{}]+)\s+from\s+)?|export\s+(type\s+)?(?:([\s\w*$,{}]+)\s+from\s+)?|import\s*\(|require\s*\()\s*["']([^"']+)["']/g;
   let match;
   while ((match = regex.exec(content)) !== null) {
-    const specifier = match[1];
+    const isTypeOnly = Boolean(match[1] || match[3]);
+    const importClause = (match[2] || match[4] || "").trim();
+    const specifier = match[5];
     const charIndex = match.index;
     const lineNum = content.substring(0, charIndex).split("\n").length;
     const rawCode = lines[lineNum - 1]?.trim() || match[0].trim();
+    const importedNames = [];
+    if (importClause) {
+      const cleaned = importClause.replace(/[{}]/g, "");
+      const words = cleaned.split(",").map((s) => s.trim()).filter(Boolean);
+      for (const w of words) {
+        const parts = w.split(/\s+as\s+/);
+        const name = parts[0].replace(/^type\s+/, "").trim();
+        const alias = (parts[1] || name).trim();
+        if (alias && alias !== "*") {
+          importedNames.push(alias);
+        }
+      }
+    }
     statements.push({
       specifier,
       line: lineNum,
-      rawCode
+      rawCode,
+      isTypeOnly,
+      importedNames
     });
   }
   return statements;
@@ -5099,6 +5134,15 @@ function discoverAllFeatures(projectRoot) {
     dir: path2.join(featuresBase, e.name)
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
+function discoverAllShared(projectRoot) {
+  const sharedBase = resolveSharedDir(projectRoot);
+  if (!fs4.existsSync(sharedBase)) return [];
+  const entries = fs4.readdirSync(sharedBase, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "__tests__" && e.name !== "tests").map((e) => ({
+    name: e.name,
+    dir: path2.join(sharedBase, e.name)
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
 function extractClassMethods(content, className) {
   let clean = "";
   let inLineComment = false;
@@ -5448,16 +5492,21 @@ function lintCodebase(options = {}) {
   const projectRoot = options.projectRoot || findProjectRoot(options.targetDir || process.cwd());
   const failFast = !options.complete;
   const features = discoverAllFeatures(projectRoot);
+  const sharedModules = discoverAllShared(projectRoot);
+  const allModules = [
+    ...features.map((f) => ({ ...f, type: "feature" })),
+    ...sharedModules.map((s) => ({ ...s, type: "shared" }))
+  ];
   const graph = new FeatureDependencyGraph();
   const allViolations = [];
   const results = [];
   const detectedCycles = [];
   const addViolation = (v) => {
     allViolations.push(v);
-    const featureResult = results.find((r) => r.featureName === v.feature);
-    if (featureResult) {
-      featureResult.violations.push(v);
-      featureResult.passed = false;
+    const moduleResult = results.find((r) => r.featureName === v.feature);
+    if (moduleResult) {
+      moduleResult.violations.push(v);
+      moduleResult.passed = false;
     }
     if (failFast) {
       const errorMsg = `Dependency rule violation detected in ${v.relativePath}:${v.line}:
@@ -5466,28 +5515,156 @@ Code: ${v.code}`;
       throw new DependencyRuleError(errorMsg, [v], true);
     }
   };
-  for (const feat of features) {
+  for (const mod of allModules) {
     results.push({
-      featureName: feat.name,
-      featureDir: feat.dir,
+      moduleType: mod.type,
+      moduleName: mod.name,
+      featureName: mod.name,
+      featureDir: mod.dir,
+      moduleDir: mod.dir,
       scannedFilesCount: 0,
       passed: true,
       violations: [],
-      layersChecked: ["domain", "useCases", "services", "infrastructure", "presentation"]
+      layersChecked: mod.type === "feature" ? ["domain", "useCases", "services", "infrastructure", "presentation"] : ["domain", "ports", "infrastructure", "root"]
     });
   }
-  for (const feat of features) {
-    const featResult = results.find((r) => r.featureName === feat.name);
-    const allFiles = scanDirFiles(feat.dir, projectRoot);
-    featResult.scannedFilesCount = allFiles.length;
+  for (const mod of allModules) {
+    const modResult = results.find((r) => r.featureName === mod.name);
+    const allFiles = scanDirFiles(mod.dir, projectRoot);
+    modResult.scannedFilesCount = allFiles.length;
     for (const file of allFiles) {
       const relPath = path2.relative(projectRoot, file).replace(/\\/g, "/");
-      const { layer } = classifyFile(file, projectRoot);
-      if (!layer) continue;
+      const { moduleType, moduleName, layer } = classifyFile(file, projectRoot);
+      if (!layer || !moduleType || !moduleName) continue;
       const content = fs4.readFileSync(file, "utf-8");
       const statements = extractImportStatements(content);
       const baseName = path2.basename(file);
       const isBarrel = baseName === "index.ts" || baseName === "index.js";
+      if (moduleType === "shared") {
+        if (layer === "domain") {
+          const lines = content.split(/\r?\n/);
+          for (let i = 0; i < lines.length; i++) {
+            const lineText = lines[i].trim();
+            if (lineText.includes("@MakeInjectable") || lineText.includes("public static deps =")) {
+              addViolation({
+                feature: moduleName,
+                layer,
+                file,
+                relativePath: relPath,
+                line: i + 1,
+                category: "Domain Dependence Violation",
+                code: lineText,
+                ruleId: "D2_DI_DEPENDENCE",
+                severity: "error",
+                advice: "Domain layer must have zero DI dependence. Remove @MakeInjectable decorators and static deps declarations.",
+                fixExample: {
+                  bad: lineText,
+                  good: "// Domain interfaces and value objects must remain plain TypeScript classes/interfaces."
+                }
+              });
+            }
+          }
+        }
+        for (const stmt of statements) {
+          const target = classifyTarget(stmt.specifier, file, projectRoot);
+          if (target.targetFeature) {
+            addViolation({
+              feature: moduleName,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Architecture Violation",
+              code: stmt.rawCode,
+              ruleId: "SF1_FEATURE_DEPENDENCY",
+              severity: "error",
+              advice: `Shared modules ('${moduleName}') are foundational and must NEVER import from feature modules ('${target.targetFeature}').`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Move shared logic/types to shared/ or communicate via domain events/callbacks."
+              }
+            });
+          }
+          if (target.targetSharedModule && target.targetSharedModule !== moduleName) {
+            if (target.isSharedInfra || target.isSharedPorts) {
+              addViolation({
+                feature: moduleName,
+                layer,
+                file,
+                relativePath: relPath,
+                line: stmt.line,
+                category: "Shared Architecture Violation",
+                code: stmt.rawCode,
+                ruleId: "SS1_SHARED_ENCAPSULATION",
+                severity: "error",
+                advice: `Shared module '${moduleName}' cannot import internal details (ports/infra) of shared module '${target.targetSharedModule}'. Depend only on its root classes or domain types.`,
+                fixExample: {
+                  bad: stmt.rawCode,
+                  good: `import { ... } from "@/shared/${target.targetSharedModule}/<RootClass>.js";`
+                }
+              });
+            }
+          }
+          if (layer === "domain") {
+            if (target.targetSharedModule === moduleName && (target.isSharedInfra || target.isSharedPorts || target.isSharedRoot)) {
+              addViolation({
+                feature: moduleName,
+                layer,
+                file,
+                relativePath: relPath,
+                line: stmt.line,
+                category: "Domain Purity Violation",
+                code: stmt.rawCode,
+                ruleId: "SD1_OUTER_IMPORT",
+                severity: "error",
+                advice: `Shared domain layer must not import from its own ports, infrastructure, or root classes.`,
+                fixExample: {
+                  bad: stmt.rawCode,
+                  good: "// Model pure business types and value objects directly within domain/."
+                }
+              });
+            }
+            if (target.isDiFramework) {
+              addViolation({
+                feature: moduleName,
+                layer,
+                file,
+                relativePath: relPath,
+                line: stmt.line,
+                category: "Domain Dependence Violation",
+                code: stmt.rawCode,
+                ruleId: "D2_DI_DEPENDENCE",
+                severity: "error",
+                advice: "Domain layer must have zero DI dependence. Domain interfaces and value objects are plain classes/types.",
+                fixExample: {
+                  bad: stmt.rawCode,
+                  good: "// Remove @solid-stack/di import. Domain entities are pure TypeScript."
+                }
+              });
+            }
+          }
+          if (layer === "ports" && target.targetSharedModule === moduleName && target.isSharedInfra) {
+            addViolation({
+              feature: moduleName,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Shared Architecture Violation",
+              code: stmt.rawCode,
+              ruleId: "SP1_INFRA_IN_PORT",
+              severity: "error",
+              advice: `Shared ports cannot depend on infrastructure. Infrastructure implements ports, not the other way around.`,
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Ports define abstract interfaces without concrete infrastructure dependencies."
+              }
+            });
+          }
+        }
+        continue;
+      }
+      const feat = mod;
       if (layer === "useCases" && !isBarrel) {
         checkUseCaseShape(feat.name, file, relPath, content, addViolation);
       }
@@ -5556,23 +5733,33 @@ Code: ${v.code}`;
               }
             });
           }
-          if (target.targetLayer === "domain" && !target.isTargetPort) {
-            addViolation({
-              feature: feat.name,
-              layer,
-              file,
-              relativePath: relPath,
-              line: stmt.line,
-              category: "Cross-Feature Domain Violation",
-              code: stmt.rawCode,
-              ruleId: "F1_CROSS_FEATURE_DOMAIN",
-              severity: "error",
-              advice: `Cannot import domain entities/factories directly from foreign feature '${target.targetFeature}'. This bypasses its use cases and breaks Bounded Context encapsulation. Communicate via ports instead.`,
-              fixExample: {
-                bad: stmt.rawCode,
-                good: `// Define a Port in ${feat.name}/domain/ and implement the cross-feature communication in ${feat.name}/infrastructure/ (which can then call ${target.targetFeature}'s Use Case).`
+          if (target.targetLayer === "domain" && !target.isTargetPort && !target.isTargetError && !stmt.isTypeOnly) {
+            for (const name of stmt.importedNames) {
+              const createRegex = new RegExp(`\\b${name}\\.create\\s*\\(`, "g");
+              const newRegex = new RegExp(`\\bnew\\s+${name}\\b`, "g");
+              const execMatch = createRegex.exec(content) || newRegex.exec(content);
+              if (execMatch) {
+                const charIndex = execMatch.index;
+                const lineNum = content.substring(0, charIndex).split("\n").length;
+                const lineCode = content.split(/\r?\n/)[lineNum - 1]?.trim() || stmt.rawCode;
+                addViolation({
+                  feature: feat.name,
+                  layer,
+                  file,
+                  relativePath: relPath,
+                  line: lineNum,
+                  category: "Cross-Feature Domain Violation",
+                  code: lineCode,
+                  ruleId: "F1_CROSS_FEATURE_DOMAIN",
+                  severity: "error",
+                  advice: `Cannot instantiate domain entities/factories directly from foreign feature '${target.targetFeature}' (found instantiation of '${name}'). This bypasses its use cases and breaks Bounded Context encapsulation. Importing for types or 'instanceof' checks is allowed.`,
+                  fixExample: {
+                    bad: lineCode,
+                    good: `// Define a Port in ${feat.name}/domain/ and implement the cross-feature communication in ${feat.name}/infrastructure/.`
+                  }
+                });
               }
-            });
+            }
           }
         }
         if (target.isGlobalConfig) {
@@ -5960,23 +6147,33 @@ Code: ${v.code}`;
               }
             });
           }
-          if (target.targetLayer === "domain" && !target.isTargetPort && !target.isTargetRepo) {
-            addViolation({
-              feature: feat.name,
-              layer,
-              file,
-              relativePath: relPath,
-              line: stmt.line,
-              category: "Presentation Layer Violation",
-              code: stmt.rawCode,
-              ruleId: "P5_DIRECT_DOMAIN_ENTITY",
-              severity: "error",
-              advice: "Presentation handlers must not directly instantiate or import domain entities/factories. They must map requests to flat DTOs and pass them to the Use Case.",
-              fixExample: {
-                bad: stmt.rawCode,
-                good: "// Construct a DTO and pass it into the injected Use Case's execute() method."
+          if (target.targetLayer === "domain" && !target.isTargetPort && !target.isTargetRepo && !target.isTargetError && !stmt.isTypeOnly) {
+            for (const name of stmt.importedNames) {
+              const createRegex = new RegExp(`\\b${name}\\.create\\s*\\(`, "g");
+              const newRegex = new RegExp(`\\bnew\\s+${name}\\b`, "g");
+              const execMatch = createRegex.exec(content) || newRegex.exec(content);
+              if (execMatch) {
+                const charIndex = execMatch.index;
+                const lineNum = content.substring(0, charIndex).split("\n").length;
+                const lineCode = content.split(/\r?\n/)[lineNum - 1]?.trim() || stmt.rawCode;
+                addViolation({
+                  feature: feat.name,
+                  layer,
+                  file,
+                  relativePath: relPath,
+                  line: lineNum,
+                  category: "Presentation Layer Violation",
+                  code: lineCode,
+                  ruleId: "P5_DIRECT_DOMAIN_ENTITY",
+                  severity: "error",
+                  advice: `Presentation handlers must not directly instantiate domain entities (found instantiation of '${name}'). They must map requests to flat DTOs and pass them to the Use Case. Importing for types or 'instanceof' checks is allowed.`,
+                  fixExample: {
+                    bad: lineCode,
+                    good: "// Construct a plain DTO object and pass it into the injected Use Case's execute() method."
+                  }
+                });
               }
-            });
+            }
           }
         }
       }