@archest/vitest 1.0.0 → 1.0.2

package/src/core/Project.ts

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

@@ -1,50 +0,0 @@
-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'),
-    };
-  }
-}

package/src/core/SliceLocator.ts

@@ -1,92 +0,0 @@
-import * as ts from 'typescript';
-import { RuleResult } from './types';
-
-export class SliceLocator {
-  private slicePattern: RegExp;
-  private sliceIds: Set<string> = new Set();
-  private sliceFiles: Map<string, ts.SourceFile[]> = new Map();
-
-  constructor(sourceFiles: ts.SourceFile[], private program: ts.Program, pattern: string) {
-    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-    const regexStr = escaped.replace(/\*/g, '([^/\\\\]+)');
-    this.slicePattern = new RegExp(regexStr);
-
-    for (const sf of sourceFiles) {
-      const match = sf.fileName.match(this.slicePattern);
-      if (match && match[1]) {
-        const sliceId = match[1];
-        this.sliceIds.add(sliceId);
-        if (!this.sliceFiles.has(sliceId)) {
-          this.sliceFiles.set(sliceId, []);
-        }
-        this.sliceFiles.get(sliceId)!.push(sf);
-      }
-    }
-  }
-
-  checkBeFreeOfCycles(isNot: boolean): RuleResult {
-    const graph: Map<string, Set<string>> = new Map();
-    for (const slice of this.sliceIds) {
-      graph.set(slice, new Set());
-    }
-
-    for (const [sliceId, files] of this.sliceFiles.entries()) {
-      for (const sf of files) {
-        ts.forEachChild(sf, (node) => {
-          if (ts.isImportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-            const importPath = node.moduleSpecifier.text;
-            const resolved = ts.resolveModuleName(importPath, sf.fileName, this.program.getCompilerOptions(), ts.sys);
-            if (resolved.resolvedModule && resolved.resolvedModule.resolvedFileName) {
-              const targetMatch = resolved.resolvedModule.resolvedFileName.match(this.slicePattern);
-              if (targetMatch && targetMatch[1]) {
-                const targetSlice = targetMatch[1];
-                if (targetSlice !== sliceId && this.sliceIds.has(targetSlice)) {
-                  graph.get(sliceId)!.add(targetSlice);
-                }
-              }
-            }
-          }
-        });
-      }
-    }
-
-    const visited = new Set<string>();
-    const recursionStack = new Set<string>();
-    const violations: string[] = [];
-
-    const dfs = (node: string, path: string[]): boolean => {
-      visited.add(node);
-      recursionStack.add(node);
-
-      for (const neighbor of (graph.get(node) || [])) {
-        if (!visited.has(neighbor)) {
-          if (dfs(neighbor, [...path, neighbor])) return true;
-        } else if (recursionStack.has(neighbor)) {
-          violations.push(`Cycle detected between slices: ${path.join(' -> ')} -> ${neighbor}`);
-          return true;
-        }
-      }
-
-      recursionStack.delete(node);
-      return false;
-    };
-
-    for (const slice of this.sliceIds) {
-      if (!visited.has(slice)) {
-        dfs(slice, [slice]);
-      }
-    }
-
-    if (isNot) {
-      return {
-        pass: violations.length > 0,
-        message: () => violations.length > 0 ? '' : 'Expected cycles between slices but found none.'
-      };
-    } else {
-      return {
-        pass: violations.length === 0,
-        message: () => violations.join('\n')
-      };
-    }
-  }
-}

package/src/core/types.ts

@@ -1,4 +0,0 @@
-export interface RuleResult {
-  pass: boolean;
-  message: () => string;
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-export { Project, parseProject } from './core/Project';
-export { setupMatchers } from './matchers';
-export * from './core/FileLocator';
-export * from './core/ClassLocator';
-export * from './core/FunctionLocator';
-export * from './core/PropertyLocator';
-export * from './core/SliceLocator';
-export * from './core/LayerLocator';
-export * from './core/types';

package/src/matchers/index.ts

@@ -1,113 +0,0 @@
-import { expect } from 'vitest';
-import { RuleResult } from '../core/types';
-import { ClassLocator } from '../core/ClassLocator';
-import { FunctionLocator } from '../core/FunctionLocator';
-import { PropertyLocator } from '../core/PropertyLocator';
-import { FileLocator } from '../core/FileLocator';
-import { SliceLocator } from '../core/SliceLocator';
-import { LayeredArchitectureBuilder } from '../core/LayerLocator';
-
-export function setupMatchers() {
-  expect.extend({
-    toPass(received: RuleResult | LayeredArchitectureBuilder) {
-      const result = received instanceof LayeredArchitectureBuilder ? received.check() : received;
-      const { pass, message } = result;
-      return {
-        pass: this.isNot ? !pass : pass,
-        message: pass 
-          ? () => 'Expected rule not to pass' 
-          : () => message()
-      };
-    },
-
-    toResideInFolder(received: ClassLocator, folder: string) {
-      const { pass, message } = received.checkResideInFolder(folder, this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    },
-
-    toHaveModifier(received: ClassLocator | FunctionLocator, modifier: string) {
-      const { pass, message } = received.checkHaveModifier(modifier, this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    },
-
-
-
-    toExtendClass(received: ClassLocator, className: string) {
-      const { pass, message } = received.checkExtendClass(className, this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    },
-
-    toImplementInterface(received: ClassLocator, interfaceName: string) {
-      const { pass, message } = received.checkImplementInterface(interfaceName, this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    },
-
-    toHaveExplicitReturnType(received: FunctionLocator) {
-      const { pass, message } = received.checkHaveExplicitReturnType(this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    },
-
-    toBeReadonly(received: PropertyLocator) {
-      const { pass, message } = received.checkBeReadonly(this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    },
-
-    toDependOnFilesInFolder(received: FileLocator, folder: string) {
-      const { pass, message } = received.checkDependOnFilesInFolder(folder, this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    },
-
-    toBeFreeOfCycles(received: FileLocator | SliceLocator) {
-      const { pass, message } = received.checkBeFreeOfCycles(this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    },
-
-    toMatchNamePattern(received: FileLocator | ClassLocator | FunctionLocator, pattern: string | RegExp) {
-      const { pass, message } = received.checkMatchNamePattern(pattern, this.isNot);
-      return {
-        pass: this.isNot ? !pass : pass,
-        message
-      };
-    }
-  });
-}
-
-declare module 'vitest' {
-  interface Assertion<T = any> {
-    toPass(): void;
-    toResideInFolder(folder: string): void;
-    toHaveModifier(modifier: 'export' | 'default' | 'abstract' | 'async' | 'private' | 'public'): void;
-
-    toExtendClass(className: string): void;
-    toImplementInterface(interfaceName: string): void;
-    toHaveExplicitReturnType(): void;
-    toBeReadonly(): void;
-    toDependOnFilesInFolder(folder: string): void;
-    toBeFreeOfCycles(): void;
-    toMatchNamePattern(pattern: string | RegExp): void;
-  }
-}

package/test/architecture.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseProject } from '../src/core/Project';
-import { setupMatchers } from '../src/matchers';
-
-setupMatchers();
-
-describe('@archest/vitest', () => {
-  const project = parseProject(); // Automatically picks up tsconfig.json in the current directory
-
-  describe('FileLocator (Dependency Checks)', () => {
-    it('core classes should not depend on matchers', () => {
-      const coreFiles = project.getFiles({ inFolder: 'core' });
-      expect(coreFiles).not.toDependOnFilesInFolder('matchers');
-    });
-
-    it('matchers should depend on core', () => {
-      const matcherFiles = project.getFiles({ inFolder: 'matchers' });
-      expect(matcherFiles).toDependOnFilesInFolder('core');
-    });
-  });
-
-  describe('ClassLocator (Declaration Checks)', () => {
-    it('locators should have export modifier', () => {
-      const locators = project.getClasses({ inFolder: 'core', matchNamePattern: /Locator$/ });
-      expect(locators).toHaveModifier('export');
-    });
-
-    it('Project class should be exported', () => {
-      const projectClasses = project.getClasses({ matchNamePattern: /Project$/ });
-      expect(projectClasses).toHaveModifier('export');
-    });
-  });
-
-  describe('FileLocator (Pattern matching)', () => {
-    it('src files should match the src pattern', () => {
-      const srcFiles = project.getFiles({ matchNamePattern: /src\/core\/.*/ });
-      expect(srcFiles).not.toDependOnFilesInFolder('matchers');
-    });
-
-    it('core classes should be free of cycles', () => {
-      const coreFiles = project.getFiles({ inFolder: 'core' });
-      expect(coreFiles).toBeFreeOfCycles();
-    });
-  });
-
-  describe('LayeredArchitectureBuilder', () => {
-    it('core should not depend on matchers layer', () => {
-      const architecture = project.layeredArchitecture()
-        .layer('Core', 'core')
-        .layer('Matchers', 'matchers')
-        .layer('Root', 'src'); // src/index.ts is just under src
-
-      const rule = architecture
-        .whereLayer('Matchers').shouldOnlyBeAccessedBy('Core', 'Root');
-
-      expect(rule).toPass();
-    });
-  });
-});

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "types": ["node"],
-    "declaration": true,
-    "sourceMap": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "outDir": "dist"
-  },
-  "include": ["src/**/*"]
-}

package/vite.config.ts

@@ -1,18 +0,0 @@
-import { defineConfig } from 'vite';
-import dts from 'vite-plugin-dts';
-import { resolve } from 'path';
-
-export default defineConfig({
-  build: {
-    lib: {
-      entry: resolve(__dirname, 'src/index.ts'),
-      name: 'VitestArch',
-      fileName: (format) => `index.${format === 'es' ? 'mjs' : 'js'}`,
-    },
-    rollupOptions: {
-      external: ['typescript', 'vitest', 'path', 'fs'],
-    },
-    sourcemap: true,
-  },
-  plugins: [dts()],
-});