@solid-stack/mason 1.0.23 → 1.0.24

package/dist/bin.cjs

@@ -4432,6 +4432,350 @@ function discoverAllFeatures(projectRoot) {
     dir: path2__default.default.join(featuresBase, e.name)
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
+function extractClassMethods(content, className) {
+  let clean = "";
+  let inLineComment = false;
+  let inBlockComment = false;
+  let inString = null;
+  let escaped = false;
+  for (let i = 0; i < content.length; i++) {
+    const c = content[i];
+    const next = content[i + 1];
+    if (inLineComment) {
+      if (c === "\n") {
+        inLineComment = false;
+        clean += "\n";
+      } else {
+        clean += " ";
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (c === "*" && next === "/") {
+        inBlockComment = false;
+        clean += "  ";
+        i++;
+      } else {
+        clean += c === "\n" ? "\n" : " ";
+      }
+      continue;
+    }
+    if (inString) {
+      clean += c === "\n" ? "\n" : " ";
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (c === inString) {
+        inString = null;
+      }
+      continue;
+    }
+    if (c === "/" && next === "/") {
+      inLineComment = true;
+      clean += "  ";
+      i++;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      inBlockComment = true;
+      clean += "  ";
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      inString = c;
+      clean += " ";
+      continue;
+    }
+    clean += c;
+  }
+  const classDeclRegex = new RegExp(`(?:export\\s+(?:default\\s+)?)?class\\s+${className}\\b[^{]*\\{`);
+  const match = classDeclRegex.exec(clean);
+  if (!match) return null;
+  const classBodyStart = match.index + match[0].length - 1;
+  const methods = [];
+  let depth = 1;
+  let parenDepth = 0;
+  let atMemberStart = true;
+  const methodRegex = /^\s*(?:@[a-zA-Z0-9_$]+(?:\([^)]*\))?\s+)*(?:(public|private|protected|static)\s+)*(?:(async)\s+)?(?:(get|set)\s+)?(#?[a-zA-Z0-9_$]+)\s*(?:<[^>]+>)?\s*\(/;
+  const arrowRegex = /^\s*(?:(public|private|protected|static)\s+)?(#?[a-zA-Z0-9_$]+)\s*=\s*(?:async\s*)?\(/;
+  for (let i = classBodyStart + 1; i < clean.length && depth > 0; i++) {
+    const c = clean[i];
+    if (c === "{") {
+      depth++;
+      atMemberStart = false;
+      continue;
+    }
+    if (c === "}") {
+      depth--;
+      if (depth === 1) {
+        atMemberStart = true;
+      }
+      continue;
+    }
+    if (depth === 1) {
+      if (c === ";") {
+        atMemberStart = true;
+        parenDepth = 0;
+        continue;
+      }
+      if (c === "(") {
+        parenDepth++;
+      } else if (c === ")") {
+        parenDepth = Math.max(0, parenDepth - 1);
+      }
+      if (atMemberStart && parenDepth === 0) {
+        if (/\s/.test(c)) continue;
+        const slice = clean.slice(i);
+        const methodMatch = slice.match(methodRegex);
+        if (methodMatch) {
+          const fullMatch = methodMatch[0];
+          const beforeParen = fullMatch.slice(0, fullMatch.lastIndexOf("(")).trim();
+          const tokens = beforeParen.split(/\s+/).filter(Boolean);
+          const rawName = tokens[tokens.length - 1] || "";
+          const methodName = rawName.replace(/<.*$/, "");
+          const controlKeywords = ["if", "for", "while", "switch", "catch", "with"];
+          if (!controlKeywords.includes(methodName)) {
+            const isPrivate = tokens.includes("private") || tokens.includes("protected") || methodName.startsWith("#");
+            const isAsync = tokens.includes("async");
+            const isPublic = !isPrivate;
+            const lineNum = content.slice(0, i).split("\n").length;
+            const lineCode = content.split("\n")[lineNum - 1]?.trim() || "";
+            methods.push({
+              name: methodName,
+              isAsync,
+              isPublic,
+              line: lineNum,
+              code: lineCode
+            });
+            i += fullMatch.length - 1;
+            parenDepth = 1;
+            atMemberStart = false;
+            continue;
+          }
+        }
+        const arrowMatch = slice.match(arrowRegex);
+        if (arrowMatch) {
+          const fullMatch = arrowMatch[0];
+          const beforeEquals = fullMatch.split("=")[0].trim();
+          const tokens = beforeEquals.split(/\s+/).filter(Boolean);
+          const rawName = tokens[tokens.length - 1] || "";
+          const isPrivate = tokens.includes("private") || tokens.includes("protected") || rawName.startsWith("#");
+          const isAsync = fullMatch.includes("async");
+          const isPublic = !isPrivate;
+          const lineNum = content.slice(0, i).split("\n").length;
+          const lineCode = content.split("\n")[lineNum - 1]?.trim() || "";
+          methods.push({
+            name: rawName,
+            isAsync,
+            isPublic,
+            line: lineNum,
+            code: lineCode
+          });
+          i += fullMatch.length - 1;
+          parenDepth = 1;
+          atMemberStart = false;
+          continue;
+        }
+        atMemberStart = false;
+      }
+    }
+  }
+  return methods;
+}
+function checkUseCaseShape(featureName, filePath, relativePath, content, addViolation) {
+  const fileName = path2__default.default.basename(filePath);
+  const lines = content.split(/\r?\n/);
+  const classMatch = content.match(/(?:export\s+(?:default\s+)?)?class\s+([A-Za-z0-9_]+)/);
+  if (!classMatch) {
+    addViolation({
+      feature: featureName,
+      layer: "useCases",
+      file: filePath,
+      relativePath,
+      line: 1,
+      category: "Use Case Shape Violation",
+      code: lines[0]?.trim() || "",
+      ruleId: "U_SHAPE_CLASS",
+      severity: "error",
+      advice: `Use case file '${fileName}' must define and export a class.`,
+      fixExample: {
+        bad: "// Missing class definition",
+        good: `export class ${fileName.replace(/\.(ts|js)$/, "")} { ... }`
+      }
+    });
+    return;
+  }
+  const className = classMatch[1];
+  let classLine = 1;
+  for (let i = 0; i < lines.length; i++) {
+    if (new RegExp(`(?:export\\s+(?:default\\s+)?)?class\\s+${className}\\b`).test(lines[i])) {
+      classLine = i + 1;
+      break;
+    }
+  }
+  if (!/@MakeInjectable\b/.test(content)) {
+    addViolation({
+      feature: featureName,
+      layer: "useCases",
+      file: filePath,
+      relativePath,
+      line: classLine,
+      category: "Use Case Shape Violation",
+      code: lines[classLine - 1]?.trim() || `class ${className}`,
+      ruleId: "U_SHAPE_DECORATOR",
+      severity: "error",
+      advice: `Use case class '${className}' in '${fileName}' must be decorated with @MakeInjectable.`,
+      fixExample: {
+        bad: lines[classLine - 1]?.trim() || `class ${className}`,
+        good: `@MakeInjectable
+export class ${className} { ... }`
+      }
+    });
+  }
+  const hasAsyncExecute = /(?:public\s+)?async\s+execute\s*(?:<[^>]+>)?\s*\(/.test(content);
+  if (!hasAsyncExecute) {
+    const hasSyncExecute = /(?:public\s+)?execute\s*(?:<[^>]+>)?\s*\(/.test(content);
+    addViolation({
+      feature: featureName,
+      layer: "useCases",
+      file: filePath,
+      relativePath,
+      line: classLine,
+      category: "Use Case Shape Violation",
+      code: lines[classLine - 1]?.trim() || `class ${className}`,
+      ruleId: "U_SHAPE_EXECUTE",
+      severity: "error",
+      advice: hasSyncExecute ? `Use case class '${className}' in '${fileName}' must have an 'async execute' method (found synchronous 'execute').` : `Use case class '${className}' in '${fileName}' must implement an 'async execute(...)' method.`,
+      fixExample: {
+        bad: hasSyncExecute ? "execute(props: ...) { ... }" : `class ${className} { ... }`,
+        good: "async execute(props: ...): Promise<...> { ... }"
+      }
+    });
+  }
+  const classMethods = extractClassMethods(content, className);
+  if (classMethods) {
+    const extraPublicMethods = classMethods.filter(
+      (m) => m.isPublic && m.name !== "constructor" && m.name !== "execute"
+    );
+    for (const m of extraPublicMethods) {
+      addViolation({
+        feature: featureName,
+        layer: "useCases",
+        file: filePath,
+        relativePath,
+        line: m.line,
+        category: "Use Case Shape Violation",
+        code: m.code || `public ${m.name}(...)`,
+        ruleId: "U_SHAPE_ONLY_EXECUTE",
+        severity: "error",
+        advice: `Use case class '${className}' in '${fileName}' has disallowed public method '${m.name}'. The only allowed public methods are constructor and async execute. Extract extra methods into their own use cases, or make them private.`,
+        fixExample: {
+          bad: m.code || `${m.name}(...) { ... }`,
+          good: `// Extract '${m.name}' into its own dedicated Use Case, or make it private if it is internal helper logic:
+private ${m.name}(...) { ... }`
+        }
+      });
+    }
+  }
+}
+function checkServiceShape(featureName, filePath, relativePath, content, addViolation) {
+  const fileName = path2__default.default.basename(filePath);
+  const lines = content.split(/\r?\n/);
+  const classMatch = content.match(/(?:export\s+(?:default\s+)?)?class\s+([A-Za-z0-9_]+)/);
+  if (!classMatch) {
+    addViolation({
+      feature: featureName,
+      layer: "services",
+      file: filePath,
+      relativePath,
+      line: 1,
+      category: "Service Shape Violation",
+      code: lines[0]?.trim() || "",
+      ruleId: "S_SHAPE_CLASS",
+      severity: "error",
+      advice: `Service file '${fileName}' must define and export a class.`,
+      fixExample: {
+        bad: "// Missing class definition",
+        good: `export class ${fileName.replace(/\.(ts|js)$/, "")} { ... }`
+      }
+    });
+    return;
+  }
+  const className = classMatch[1];
+  let classLine = 1;
+  for (let i = 0; i < lines.length; i++) {
+    if (new RegExp(`(?:export\\s+(?:default\\s+)?)?class\\s+${className}\\b`).test(lines[i])) {
+      classLine = i + 1;
+      break;
+    }
+  }
+  if (!/@MakeInjectable\b/.test(content)) {
+    addViolation({
+      feature: featureName,
+      layer: "services",
+      file: filePath,
+      relativePath,
+      line: classLine,
+      category: "Service Shape Violation",
+      code: lines[classLine - 1]?.trim() || `class ${className}`,
+      ruleId: "S_SHAPE_DECORATOR",
+      severity: "error",
+      advice: `Service class '${className}' in '${fileName}' must be decorated with @MakeInjectable.`,
+      fixExample: {
+        bad: lines[classLine - 1]?.trim() || `class ${className}`,
+        good: `@MakeInjectable
+export class ${className} { ... }`
+      }
+    });
+  }
+  const hasAsyncExecute = /(?:public\s+)?async\s+execute\s*(?:<[^>]+>)?\s*\(/.test(content);
+  if (!hasAsyncExecute) {
+    const hasSyncExecute = /(?:public\s+)?execute\s*(?:<[^>]+>)?\s*\(/.test(content);
+    addViolation({
+      feature: featureName,
+      layer: "services",
+      file: filePath,
+      relativePath,
+      line: classLine,
+      category: "Service Shape Violation",
+      code: lines[classLine - 1]?.trim() || `class ${className}`,
+      ruleId: "S_SHAPE_EXECUTE",
+      severity: "error",
+      advice: hasSyncExecute ? `Service class '${className}' in '${fileName}' must have an 'async execute' method (found synchronous 'execute').` : `Service class '${className}' in '${fileName}' must implement an 'async execute(...)' method.`,
+      fixExample: {
+        bad: hasSyncExecute ? "execute(props: ...) { ... }" : `class ${className} { ... }`,
+        good: "async execute(props: ...): Promise<...> { ... }"
+      }
+    });
+  }
+  const classMethods = extractClassMethods(content, className);
+  if (classMethods) {
+    const extraPublicMethods = classMethods.filter(
+      (m) => m.isPublic && m.name !== "constructor" && m.name !== "execute"
+    );
+    for (const m of extraPublicMethods) {
+      addViolation({
+        feature: featureName,
+        layer: "services",
+        file: filePath,
+        relativePath,
+        line: m.line,
+        category: "Service Shape Violation",
+        code: m.code || `public ${m.name}(...)`,
+        ruleId: "S_SHAPE_ONLY_EXECUTE",
+        severity: "error",
+        advice: `Service class '${className}' in '${fileName}' has disallowed public method '${m.name}'. The only allowed public methods are constructor and async execute. If a service has multiple public methods, those should be on their own services instead of being cramped in a single service.`,
+        fixExample: {
+          bad: m.code || `${m.name}(...) { ... }`,
+          good: `// Extract '${m.name}' into its own dedicated Service, or make it private if it is internal helper logic:
+private ${m.name}(...) { ... }`
+        }
+      });
+    }
+  }
+}
 function lintCodebase(options = {}) {
   const startTime = Date.now();
   const projectRoot = options.projectRoot || findProjectRoot(options.targetDir || process.cwd());
@@ -4475,6 +4819,14 @@ Code: ${v.code}`;
       if (!layer) continue;
       const content = fs9__default.default.readFileSync(file, "utf-8");
       const statements = extractImportStatements(content);
+      const baseName = path2__default.default.basename(file);
+      const isBarrel = baseName === "index.ts" || baseName === "index.js";
+      if (layer === "useCases" && !isBarrel) {
+        checkUseCaseShape(feat.name, file, relPath, content, addViolation);
+      }
+      if (layer === "services" && !isBarrel) {
+        checkServiceShape(feat.name, file, relPath, content, addViolation);
+      }
       if (layer === "domain") {
         const lines = content.split(/\r?\n/);
         for (let i = 0; i < lines.length; i++) {
@@ -4885,6 +5237,24 @@ Code: ${v.code}`;
               }
             });
           }
+          if (target.targetLayer === "services") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Presentation Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "P4_DIRECT_SERVICE",
+              severity: "error",
+              advice: "Presentation handlers must not depend on services directly. They must use use cases, and use cases will then depend on the service.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Inject a Use Case via static deps instead of a Service."
+              }
+            });
+          }
         }
       }
     }