@archest/vitest 1.0.0

package/src/core/SliceLocator.ts

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

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

package/src/index.ts

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

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

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

@@ -0,0 +1,17 @@
+{
+  "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

@@ -0,0 +1,18 @@
+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()],
+});