@archest/vitest 1.0.0

package/src/core/FileLocator.ts

@@ -0,0 +1,168 @@
+import * as ts from 'typescript';
+import { RuleResult } from './types';
+
+export interface FileQueryOptions {
+  inFolder?: string;
+  matchNamePattern?: string | RegExp;
+}
+
+export class FileLocator {
+  public readonly files: ts.SourceFile[];
+
+  constructor(sourceFiles: ts.SourceFile[], private program: ts.Program, options?: FileQueryOptions) {
+    let filtered = sourceFiles;
+
+    if (options?.inFolder) {
+      filtered = filtered.filter((file) => file.fileName.includes(`/${options.inFolder}/`) || file.fileName.includes(`\\${options.inFolder}\\`));
+    }
+    if (options?.matchNamePattern) {
+      const regex = typeof options.matchNamePattern === 'string' ? new RegExp(options.matchNamePattern) : options.matchNamePattern;
+      filtered = filtered.filter((file) => regex.test(file.fileName));
+    }
+
+    this.files = filtered;
+  }
+
+  private getFileDependencies(sourceFile: ts.SourceFile): string[] {
+    const dependencies: string[] = [];
+    const compilerOptions = this.program.getCompilerOptions();
+
+    const visit = (node: ts.Node) => {
+      if (ts.isImportDeclaration(node)) {
+        const moduleSpecifier = (node.moduleSpecifier as ts.StringLiteral).text;
+        const resolved = ts.resolveModuleName(
+          moduleSpecifier,
+          sourceFile.fileName,
+          compilerOptions,
+          ts.sys
+        );
+        if (resolved.resolvedModule && resolved.resolvedModule.resolvedFileName) {
+          if (!resolved.resolvedModule.isExternalLibraryImport) {
+            dependencies.push(resolved.resolvedModule.resolvedFileName);
+          }
+        }
+      } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+        const moduleSpecifier = (node.moduleSpecifier as ts.StringLiteral).text;
+        const resolved = ts.resolveModuleName(
+          moduleSpecifier,
+          sourceFile.fileName,
+          compilerOptions,
+          ts.sys
+        );
+        if (resolved.resolvedModule && resolved.resolvedModule.resolvedFileName) {
+          if (!resolved.resolvedModule.isExternalLibraryImport) {
+            dependencies.push(resolved.resolvedModule.resolvedFileName);
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+
+    visit(sourceFile);
+    return dependencies;
+  }
+
+  checkDependOnFilesInFolder(targetFolder: string, isNot: boolean): RuleResult {
+    const violations: string[] = [];
+
+    for (const file of this.files) {
+      const dependencies = this.getFileDependencies(file);
+      
+      const dependsOnTarget = dependencies.some((depPath) => depPath.includes(`/${targetFolder}/`) || depPath.includes(`\\${targetFolder}\\`));
+
+      if (isNot && dependsOnTarget) {
+        violations.push(`File ${file.fileName} depends on files in ${targetFolder}, but it shouldn't.`);
+      } else if (!isNot && !dependsOnTarget) {
+        violations.push(`File ${file.fileName} does not depend on files in ${targetFolder}, but it should.`);
+      }
+    }
+
+    return {
+      pass: violations.length === 0,
+      message: () => violations.join('\n'),
+    };
+  }
+
+  checkBeFreeOfCycles(isNot: boolean): RuleResult {
+    const violations: string[] = [];
+    const targetedFilePaths = new Set<string>(this.files.map(f => f.fileName));
+    const graph = new Map<string, string[]>();
+
+    for (const file of this.files) {
+      const filePath = file.fileName;
+      const dependencies = this.getFileDependencies(file)
+        .filter((p) => targetedFilePaths.has(p));
+      
+      graph.set(filePath, dependencies);
+    }
+
+    const visited = new Set<string>();
+    const recStack = new Set<string>();
+    const cycles: string[][] = [];
+
+    const isCyclicUtil = (node: string, path: string[]) => {
+      if (recStack.has(node)) {
+        const cycleStartIndex = path.indexOf(node);
+        const cycleStr = [...path.slice(cycleStartIndex), node].join('->');
+        if (!cycles.some(c => c.join('->') === cycleStr)) {
+            cycles.push([...path.slice(cycleStartIndex), node]);
+        }
+        return true;
+      }
+
+      if (visited.has(node)) return false;
+
+      visited.add(node);
+      recStack.add(node);
+      path.push(node);
+
+      const neighbors = graph.get(node) || [];
+      for (const neighbor of neighbors) {
+        isCyclicUtil(neighbor, path);
+      }
+
+      recStack.delete(node);
+      path.pop();
+      return false;
+    };
+
+    for (const node of graph.keys()) {
+      if (!visited.has(node)) {
+        isCyclicUtil(node, []);
+      }
+    }
+
+    if (isNot && cycles.length === 0) {
+      violations.push('Expected cyclic dependencies, but found none.');
+    } else if (!isNot && cycles.length > 0) {
+      for (const cycle of cycles) {
+        violations.push(`Cycle detected: ${cycle.join(' -> ')}`);
+      }
+    }
+
+    return {
+      pass: violations.length === 0,
+      message: () => violations.join('\n'),
+    };
+  }
+
+  checkMatchNamePattern(pattern: string | RegExp, isNot: boolean): RuleResult {
+    const violations: string[] = [];
+    const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+
+    for (const file of this.files) {
+      const matches = regex.test(file.fileName);
+
+      if (isNot && matches) {
+        violations.push(`File ${file.fileName} matches pattern ${pattern}, but it shouldn't.`);
+      } else if (!isNot && !matches) {
+        violations.push(`File ${file.fileName} does not match pattern ${pattern}, but it should.`);
+      }
+    }
+
+    return {
+      pass: violations.length === 0,
+      message: () => violations.join('\n'),
+    };
+  }
+}

package/src/core/FunctionLocator.ts

@@ -0,0 +1,105 @@
+import * as ts from 'typescript';
+import { RuleResult } from './types';
+
+export interface FunctionQueryOptions {
+  inFolder?: string;
+  matchNamePattern?: string | RegExp;
+  isTopLevel?: boolean;
+}
+
+export class FunctionLocator {
+  public readonly functions: ts.FunctionLikeDeclaration[];
+
+  constructor(functions: ts.FunctionLikeDeclaration[], private program: ts.Program, options?: FunctionQueryOptions) {
+    let filtered = functions;
+
+    if (options?.inFolder) {
+      filtered = filtered.filter((f) => {
+        const sourceFile = f.getSourceFile();
+        return sourceFile.fileName.includes(`/${options.inFolder}/`) || sourceFile.fileName.includes(`\\${options.inFolder}\\`);
+      });
+    }
+
+    if (options?.matchNamePattern) {
+      const regex = typeof options.matchNamePattern === 'string' ? new RegExp(options.matchNamePattern) : options.matchNamePattern;
+      filtered = filtered.filter((f) => {
+        return f.name && ts.isIdentifier(f.name) && regex.test(f.name.text);
+      });
+    }
+
+    if (options?.isTopLevel) {
+      filtered = filtered.filter((f) => {
+        return ts.isSourceFile(f.parent);
+      });
+    }
+
+    this.functions = filtered;
+  }
+
+  checkHaveModifier(modifierStr: string, isNot: boolean): RuleResult {
+    let targetKind: ts.SyntaxKind;
+    switch (modifierStr) {
+      case 'export': targetKind = ts.SyntaxKind.ExportKeyword; break;
+      case 'async': targetKind = ts.SyntaxKind.AsyncKeyword; break;
+      case 'private': targetKind = ts.SyntaxKind.PrivateKeyword; break;
+      case 'public': targetKind = ts.SyntaxKind.PublicKeyword; break;
+      default:
+        throw new Error(`Modifier ${modifierStr} is not fully supported.`);
+    }
+
+    const violations: string[] = [];
+    for (const f of this.functions) {
+      const name = f.name && ts.isIdentifier(f.name) ? f.name.text : 'Anonymous Function';
+      const modifiers = ts.canHaveModifiers(f) ? ts.getModifiers(f) : undefined;
+      const matches = modifiers && modifiers.some((m: ts.Modifier) => m.kind === targetKind);
+
+      if (isNot && matches) {
+        violations.push(`Function ${name} has modifier ${modifierStr}, but it shouldn't.`);
+      } else if (!isNot && !matches) {
+        violations.push(`Function ${name} does not have modifier ${modifierStr}, but it should.`);
+      }
+    }
+    return {
+      pass: violations.length === 0,
+      message: () => violations.join('\n'),
+    };
+  }
+
+  checkHaveExplicitReturnType(isNot: boolean): RuleResult {
+    const violations: string[] = [];
+    for (const f of this.functions) {
+      const name = f.name && ts.isIdentifier(f.name) ? f.name.text : 'Anonymous Function';
+      const hasType = !!f.type;
+
+      if (isNot && hasType) {
+        violations.push(`Function ${name} has an explicit return type, but it shouldn't.`);
+      } else if (!isNot && !hasType) {
+        violations.push(`Function ${name} does not have an explicit return type, but it should.`);
+      }
+    }
+    return {
+      pass: violations.length === 0,
+      message: () => violations.join('\n'),
+    };
+  }
+
+  checkMatchNamePattern(pattern: string | RegExp, isNot: boolean): RuleResult {
+    const violations: string[] = [];
+    const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+
+    for (const f of this.functions) {
+      const name = f.name && ts.isIdentifier(f.name) ? f.name.text : undefined;
+      const matches = name && regex.test(name);
+      
+      if (isNot && matches) {
+        violations.push(`Function ${name} matches pattern ${pattern}, but it shouldn't.`);
+      } else if (!isNot && !matches) {
+        violations.push(`Function ${name || 'Anonymous Function'} does not match pattern ${pattern}, but it should.`);
+      }
+    }
+    return {
+      pass: violations.length === 0,
+      message: () => violations.join('\n'),
+    };
+  }
+}

package/src/core/LayerLocator.ts

@@ -0,0 +1,119 @@
+import * as ts from 'typescript';
+import { RuleResult } from './types';
+
+export class LayeredArchitectureBuilder {
+  private files: ts.SourceFile[];
+  private layers = new Map<string, string>();
+  private assertions: Array<(files: ts.SourceFile[]) => string[]> = [];
+
+  constructor(files: ts.SourceFile[], public program: ts.Program) {
+    this.files = files;
+  }
+
+  layer(name: string, folderPattern: string): this {
+    this.layers.set(name, folderPattern);
+    return this;
+  }
+
+  whereLayer(name: string): LayerAssertionBuilder {
+    if (!this.layers.has(name)) {
+      throw new Error(`Layer ${name} is not defined`);
+    }
+    return new LayerAssertionBuilder(this, name);
+  }
+
+  addAssertion(assertion: (files: ts.SourceFile[]) => string[]) {
+    this.assertions.push(assertion);
+  }
+
+  getFiles(): ts.SourceFile[] {
+    return this.files;
+  }
+
+  getLayerPattern(name: string): string {
+    return this.layers.get(name)!;
+  }
+
+  getFileDependencies(sourceFile: ts.SourceFile): string[] {
+    const dependencies: string[] = [];
+    const compilerOptions = this.program.getCompilerOptions();
+
+    const visit = (node: ts.Node) => {
+      if (ts.isImportDeclaration(node)) {
+        const moduleSpecifier = (node.moduleSpecifier as ts.StringLiteral).text;
+        const resolved = ts.resolveModuleName(moduleSpecifier, sourceFile.fileName, compilerOptions, ts.sys);
+        if (resolved.resolvedModule && resolved.resolvedModule.resolvedFileName && !resolved.resolvedModule.isExternalLibraryImport) {
+          dependencies.push(resolved.resolvedModule.resolvedFileName);
+        }
+      } else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+        const moduleSpecifier = (node.moduleSpecifier as ts.StringLiteral).text;
+        const resolved = ts.resolveModuleName(moduleSpecifier, sourceFile.fileName, compilerOptions, ts.sys);
+        if (resolved.resolvedModule && resolved.resolvedModule.resolvedFileName && !resolved.resolvedModule.isExternalLibraryImport) {
+          dependencies.push(resolved.resolvedModule.resolvedFileName);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+
+    visit(sourceFile);
+    return dependencies;
+  }
+
+  check(): RuleResult {
+    const violations: string[] = [];
+    for (const assertion of this.assertions) {
+      violations.push(...assertion(this.files));
+    }
+    return {
+      pass: violations.length === 0,
+      message: () => violations.join('\n')
+    };
+  }
+}
+
+export class LayerAssertionBuilder {
+  constructor(private parent: LayeredArchitectureBuilder, private targetLayer: string) {}
+
+  shouldNotBeAccessedByAnyLayer(): LayeredArchitectureBuilder {
+    this.parent.addAssertion((files) => {
+      const violations: string[] = [];
+      const targetPattern = this.parent.getLayerPattern(this.targetLayer);
+
+      for (const file of files) {
+        const filePath = file.fileName;
+        if (!filePath.includes(`/${targetPattern}/`) && !filePath.includes(`\\${targetPattern}\\`)) {
+          const dependencies = this.parent.getFileDependencies(file);
+          const importsTarget = dependencies.some(dep => dep.includes(`/${targetPattern}/`) || dep.includes(`\\${targetPattern}\\`));
+          if (importsTarget) {
+            violations.push(`File ${filePath} accesses layer ${this.targetLayer} but it shouldn't.`);
+          }
+        }
+      }
+      return violations;
+    });
+    return this.parent;
+  }
+
+  shouldOnlyBeAccessedBy(...allowedLayers: string[]): LayeredArchitectureBuilder {
+    this.parent.addAssertion((files) => {
+      const violations: string[] = [];
+      const targetPattern = this.parent.getLayerPattern(this.targetLayer);
+      const allowedPatterns = allowedLayers.map(l => this.parent.getLayerPattern(l));
+
+      for (const file of files) {
+        const filePath = file.fileName;
+        const isInAllowedLayer = allowedPatterns.some(p => filePath.includes(`/${p}/`) || filePath.includes(`\\${p}\\`));
+        
+        if (!filePath.includes(`/${targetPattern}/`) && !filePath.includes(`\\${targetPattern}\\`) && !isInAllowedLayer) {
+          const dependencies = this.parent.getFileDependencies(file);
+          const importsTarget = dependencies.some(dep => dep.includes(`/${targetPattern}/`) || dep.includes(`\\${targetPattern}\\`));
+          if (importsTarget) {
+            violations.push(`File ${filePath} accesses layer ${this.targetLayer} but only ${allowedLayers.join(', ')} are allowed.`);
+          }
+        }
+      }
+      return violations;
+    });
+    return this.parent;
+  }
+}

package/src/core/Project.ts

@@ -0,0 +1,171 @@
+import * as ts from 'typescript';
+import * as path from 'path';
+import { FileLocator, FileQueryOptions } from './FileLocator';
+import { ClassLocator, ClassQueryOptions } from './ClassLocator';
+import { LayeredArchitectureBuilder } from './LayerLocator';
+import { FunctionLocator, FunctionQueryOptions } from './FunctionLocator';
+import { PropertyLocator, PropertyQueryOptions } from './PropertyLocator';
+import { SliceLocator } from './SliceLocator';
+
+export class Project {
+  private program: ts.Program;
+  private typeChecker: ts.TypeChecker;
+
+  constructor(options: { tsConfigFilePath?: string } = {}) {
+    let compilerOptions: ts.CompilerOptions = {};
+    const configPath = options.tsConfigFilePath || ts.findConfigFile(
+      process.cwd(),
+      ts.sys.fileExists,
+      'tsconfig.json'
+    );
+
+    if (configPath) {
+      const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+      const parsedCommandLine = ts.parseJsonConfigFileContent(
+        configFile.config,
+        ts.sys,
+        path.dirname(configPath),
+        undefined,
+        configPath,
+        undefined,
+        [
+          { extension: '.vue', isMixedContent: true, scriptKind: ts.ScriptKind.TS },
+          { extension: '.svelte', isMixedContent: true, scriptKind: ts.ScriptKind.TS }
+        ]
+      );
+      compilerOptions = parsedCommandLine.options;
+
+      const host = ts.createCompilerHost(compilerOptions);
+      const originalGetSourceFile = host.getSourceFile;
+
+      let vueCompiler: any;
+      try {
+        vueCompiler = require('@vue/compiler-sfc');
+      } catch (e) {
+        // Not a Vue project
+      }
+
+      host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+        if (fileName.endsWith('.vue')) {
+          const content = ts.sys.readFile(fileName);
+          if (content) {
+            let scriptContent = '';
+            if (vueCompiler) {
+              const parsed = vueCompiler.parse(content);
+              const script = parsed.descriptor.script;
+              const scriptSetup = parsed.descriptor.scriptSetup;
+              if (script) scriptContent += script.content + '\n';
+              if (scriptSetup) scriptContent += scriptSetup.content + '\n';
+            } else {
+              // Fallback for Svelte or if compiler-sfc is missing (fragile but works for simple cases)
+              const match = content.match(/<script[^>]*>(.*?)<\/script>/s);
+              if (match) scriptContent = match[1];
+            }
+            return ts.createSourceFile(fileName, scriptContent, languageVersion, true, ts.ScriptKind.TS);
+          }
+        }
+        
+        if (fileName.endsWith('.svelte')) {
+          const content = ts.sys.readFile(fileName);
+          if (content) {
+            let scriptContent = '';
+            const match = content.match(/<script[^>]*>(.*?)<\/script>/s);
+            if (match) scriptContent = match[1];
+            return ts.createSourceFile(fileName, scriptContent, languageVersion, true, ts.ScriptKind.TS);
+          }
+        }
+
+        return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
+      };
+
+      this.program = ts.createProgram({
+        rootNames: parsedCommandLine.fileNames,
+        options: compilerOptions,
+        host: host
+      });
+    } else {
+      throw new Error("Could not find tsconfig.json");
+    }
+
+    this.typeChecker = this.program.getTypeChecker();
+  }
+
+  getFiles(options?: FileQueryOptions) {
+    const sourceFiles = this.program.getSourceFiles().filter(
+      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
+    );
+    return new FileLocator(sourceFiles, this.program, options);
+  }
+
+  getClasses(options?: ClassQueryOptions) {
+    const sourceFiles = this.program.getSourceFiles().filter(
+      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
+    );
+    
+    const allClasses: ts.ClassDeclaration[] = [];
+    for (const sf of sourceFiles) {
+      const visit = (node: ts.Node) => {
+        if (ts.isClassDeclaration(node)) {
+          allClasses.push(node);
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(sf);
+    }
+    return new ClassLocator(allClasses, this.program, options);
+  }
+
+  layeredArchitecture() {
+    const sourceFiles = this.program.getSourceFiles().filter(
+      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
+    );
+    return new LayeredArchitectureBuilder(sourceFiles, this.program);
+  }
+
+  getFunctions(options?: FunctionQueryOptions) {
+    const sourceFiles = this.program.getSourceFiles().filter(
+      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
+    );
+    
+    const allFunctions: ts.FunctionLikeDeclaration[] = [];
+    for (const sf of sourceFiles) {
+      const visit = (node: ts.Node) => {
+        if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isArrowFunction(node)) {
+          allFunctions.push(node);
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(sf);
+    }
+    return new FunctionLocator(allFunctions, this.program, options);
+  }
+
+  getProperties(options?: PropertyQueryOptions) {
+    const sourceFiles = this.program.getSourceFiles().filter(
+      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
+    );
+    
+    const allProperties: ts.PropertyDeclaration[] = [];
+    for (const sf of sourceFiles) {
+      const visit = (node: ts.Node) => {
+        if (ts.isPropertyDeclaration(node)) {
+          allProperties.push(node);
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(sf);
+    }
+    return new PropertyLocator(allProperties, this.program, options);
+  }
+
+  getSlices(pattern: string) {
+    const sourceFiles = this.program.getSourceFiles().filter(
+      sf => !sf.isDeclarationFile && !sf.fileName.includes('node_modules')
+    );
+    return new SliceLocator(sourceFiles, this.program, pattern);
+  }
+}
+
+export function parseProject(tsConfigFilePath?: string): Project {
+  return new Project({ tsConfigFilePath });
+}

package/src/core/PropertyLocator.ts

@@ -0,0 +1,50 @@
+import * as ts from 'typescript';
+import { RuleResult } from './types';
+
+export interface PropertyQueryOptions {
+  inFolder?: string;
+  matchNamePattern?: string | RegExp;
+}
+
+export class PropertyLocator {
+  public readonly properties: ts.PropertyDeclaration[];
+
+  constructor(properties: ts.PropertyDeclaration[], private program: ts.Program, options?: PropertyQueryOptions) {
+    let filtered = properties;
+
+    if (options?.inFolder) {
+      filtered = filtered.filter((p) => {
+        const sourceFile = p.getSourceFile();
+        return sourceFile.fileName.includes(`/${options.inFolder}/`) || sourceFile.fileName.includes(`\\${options.inFolder}\\`);
+      });
+    }
+
+    if (options?.matchNamePattern) {
+      const regex = typeof options.matchNamePattern === 'string' ? new RegExp(options.matchNamePattern) : options.matchNamePattern;
+      filtered = filtered.filter((p) => {
+        return ts.isIdentifier(p.name) && regex.test(p.name.text);
+      });
+    }
+
+    this.properties = filtered;
+  }
+
+  checkBeReadonly(isNot: boolean): RuleResult {
+    const violations: string[] = [];
+    for (const p of this.properties) {
+      const name = ts.isIdentifier(p.name) ? p.name.text : 'Anonymous Property';
+      const modifiers = ts.canHaveModifiers(p) ? ts.getModifiers(p) : undefined;
+      const matches = modifiers && modifiers.some((m: ts.Modifier) => m.kind === ts.SyntaxKind.ReadonlyKeyword);
+
+      if (isNot && matches) {
+        violations.push(`Property ${name} is readonly, but it shouldn't be.`);
+      } else if (!isNot && !matches) {
+        violations.push(`Property ${name} is not readonly, but it should be.`);
+      }
+    }
+    return {
+      pass: violations.length === 0,
+      message: () => violations.join('\n'),
+    };
+  }
+}