@archest/vitest 1.0.0 → 1.0.2

package/src/core/ClassLocator.ts

@@ -1,226 +0,0 @@
-import * as ts from 'typescript';
-import { RuleResult } from './types';
-
-export interface ClassQueryOptions {
-  inFolder?: string;
-  matchNamePattern?: string | RegExp;
-  withDecorator?: string;
-  extending?: string;
-  implementing?: string;
-  havingModifier?: string;
-}
-
-export class ClassLocator {
-  public readonly classes: ts.ClassDeclaration[];
-
-  constructor(classes: ts.ClassDeclaration[], private program: ts.Program, options?: ClassQueryOptions) {
-    let filtered = classes;
-
-    if (options?.inFolder) {
-      filtered = filtered.filter((c) => {
-        const sourceFile = c.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((c) => {
-        const name = c.name?.text;
-        return name && regex.test(name);
-      });
-    }
-    if (options?.withDecorator) {
-      filtered = filtered.filter((c) => {
-        const decorators = ts.canHaveDecorators(c) ? ts.getDecorators(c) : undefined;
-        let hasDecorator = false;
-        if (decorators) {
-          for (const dec of decorators) {
-            const exp = dec.expression;
-            let name = '';
-            if (ts.isIdentifier(exp)) {
-              name = exp.text;
-            } else if (ts.isCallExpression(exp) && ts.isIdentifier(exp.expression)) {
-              name = exp.expression.text;
-            }
-            if (name === options.withDecorator) {
-              hasDecorator = true;
-            }
-          }
-        }
-        return hasDecorator;
-      });
-    }
-    if (options?.extending) {
-      filtered = filtered.filter((c) => {
-        if (c.heritageClauses) {
-          for (const clause of c.heritageClauses) {
-            if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-              for (const type of clause.types) {
-                if (ts.isIdentifier(type.expression) && type.expression.text === options.extending) {
-                  return true;
-                }
-              }
-            }
-          }
-        }
-        return false;
-      });
-    }
-    if (options?.implementing) {
-      filtered = filtered.filter((c) => {
-        if (c.heritageClauses) {
-          for (const clause of c.heritageClauses) {
-            if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
-              for (const type of clause.types) {
-                if (ts.isIdentifier(type.expression) && type.expression.text === options.implementing) {
-                  return true;
-                }
-              }
-            }
-          }
-        }
-        return false;
-      });
-    }
-    if (options?.havingModifier) {
-      let targetKind: ts.SyntaxKind;
-      switch (options.havingModifier) {
-        case 'export': targetKind = ts.SyntaxKind.ExportKeyword; break;
-        case 'default': targetKind = ts.SyntaxKind.DefaultKeyword; break;
-        case 'abstract': targetKind = ts.SyntaxKind.AbstractKeyword; break;
-        default:
-          throw new Error(`Modifier ${options.havingModifier} is not fully supported.`);
-      }
-      filtered = filtered.filter((c) => {
-        const modifiers = ts.canHaveModifiers(c) ? ts.getModifiers(c) : undefined;
-        return modifiers && modifiers.some((m: ts.Modifier) => m.kind === targetKind);
-      });
-    }
-
-    this.classes = filtered;
-  }
-
-  checkResideInFolder(targetFolder: string, isNot: boolean): RuleResult {
-    const violations: string[] = [];
-    for (const c of this.classes) {
-      const className = c.name?.text || 'Anonymous Class';
-      const sourceFile = c.getSourceFile();
-      const inTargetFolder = sourceFile.fileName.includes(`/${targetFolder}/`) || sourceFile.fileName.includes(`\\${targetFolder}\\`);
-
-      if (isNot && inTargetFolder) {
-        violations.push(`Class ${className} resides in ${targetFolder}, but it shouldn't.`);
-      } else if (!isNot && !inTargetFolder) {
-        violations.push(`Class ${className} does not reside in ${targetFolder}, 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 c of this.classes) {
-      const name = c.name?.text;
-      const matches = name && regex.test(name);
-      if (isNot && matches) {
-        violations.push(`Class ${name} matches pattern ${pattern}, but it shouldn't.`);
-      } else if (!isNot && !matches) {
-        violations.push(`Class ${name || 'Anonymous'} does not match pattern ${pattern}, but it should.`);
-      }
-    }
-    return {
-      pass: violations.length === 0,
-      message: () => violations.join('\n'),
-    };
-  }
-
-  checkExtendClass(className: string, isNot: boolean): RuleResult {
-    const violations: string[] = [];
-    for (const c of this.classes) {
-      const name = c.name?.text || 'Anonymous';
-      let matches = false;
-      if (c.heritageClauses) {
-        for (const clause of c.heritageClauses) {
-          if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
-            for (const type of clause.types) {
-              if (ts.isIdentifier(type.expression) && type.expression.text === className) {
-                matches = true;
-                break;
-              }
-            }
-          }
-        }
-      }
-      if (isNot && matches) {
-        violations.push(`Class ${name} extends ${className}, but it shouldn't.`);
-      } else if (!isNot && !matches) {
-        violations.push(`Class ${name} does not extend ${className}, but it should.`);
-      }
-    }
-    return {
-      pass: violations.length === 0,
-      message: () => violations.join('\n'),
-    };
-  }
-
-  checkImplementInterface(interfaceName: string, isNot: boolean): RuleResult {
-    const violations: string[] = [];
-    for (const c of this.classes) {
-      const name = c.name?.text || 'Anonymous';
-      let matches = false;
-      if (c.heritageClauses) {
-        for (const clause of c.heritageClauses) {
-          if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
-            for (const type of clause.types) {
-              if (ts.isIdentifier(type.expression) && type.expression.text === interfaceName) {
-                matches = true;
-                break;
-              }
-            }
-          }
-        }
-      }
-      if (isNot && matches) {
-        violations.push(`Class ${name} implements ${interfaceName}, but it shouldn't.`);
-      } else if (!isNot && !matches) {
-        violations.push(`Class ${name} does not implement ${interfaceName}, but it should.`);
-      }
-    }
-    return {
-      pass: violations.length === 0,
-      message: () => violations.join('\n'),
-    };
-  }
-
-  checkHaveModifier(modifierStr: string, isNot: boolean): RuleResult {
-    let targetKind: ts.SyntaxKind;
-    switch (modifierStr) {
-      case 'export': targetKind = ts.SyntaxKind.ExportKeyword; break;
-      case 'default': targetKind = ts.SyntaxKind.DefaultKeyword; break;
-      case 'abstract': targetKind = ts.SyntaxKind.AbstractKeyword; break;
-      default:
-        throw new Error(`Modifier ${modifierStr} is not fully supported.`);
-    }
-
-    const violations: string[] = [];
-    for (const c of this.classes) {
-      const name = c.name?.text || 'Anonymous';
-      const modifiers = ts.canHaveModifiers(c) ? ts.getModifiers(c) : undefined;
-      const matches = modifiers && modifiers.some((m: ts.Modifier) => m.kind === targetKind);
-
-      if (isNot && matches) {
-        violations.push(`Class ${name} has modifier ${modifierStr}, but it shouldn't.`);
-      } else if (!isNot && !matches) {
-        violations.push(`Class ${name} does not have modifier ${modifierStr}, but it should.`);
-      }
-    }
-    return {
-      pass: violations.length === 0,
-      message: () => violations.join('\n'),
-    };
-  }
-}

package/src/core/FileLocator.ts

@@ -1,168 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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;
-  }
-}