@archest/vitest 1.0.0 → 1.0.1

package/src/core/functions/functionCheckHaveNameMatchingFileName.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getFunctions } from '../testUtils';
+import { functionCheckHaveNameMatchingFileName } from './functionCheckHaveNameMatchingFileName';
+import type { FunctionLocatorData } from './types';
+
+describe('functionCheckHaveNameMatchingFileName', () => {
+  it('should pass if function matches filename', () => {
+    const sourceFile = createSourceFile(`function test() {}`, 'test.ts');
+    const data: FunctionLocatorData = {
+      type: 'FunctionLocator',
+      functions: getFunctions(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = functionCheckHaveNameMatchingFileName(data, false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if function does not match filename', () => {
+    const sourceFile = createSourceFile(`function test() {}`, 'other.ts');
+    const data: FunctionLocatorData = {
+      type: 'FunctionLocator',
+      functions: getFunctions(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = functionCheckHaveNameMatchingFileName(data, false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/functions/functionCheckHaveNameMatchingFileName.ts

@@ -0,0 +1,16 @@
+import * as ts from 'typescript';
+import { sharedCheckHaveNameMatchingFileName } from '../shared/sharedCheckHaveNameMatchingFileName';
+import type { RuleResult } from '../types';
+import type { FunctionLocatorData } from './types';
+
+export function functionCheckHaveNameMatchingFileName(
+  locator: FunctionLocatorData,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckHaveNameMatchingFileName(
+    locator.functions,
+    (f) => (f.name && ts.isIdentifier(f.name) ? f.name.text : undefined),
+    'Function',
+    isNot,
+  );
+}

package/src/core/functions/functionCheckMatchNamePattern.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getFunctions } from '../testUtils';
+import { functionCheckMatchNamePattern } from './functionCheckMatchNamePattern';
+import type { FunctionLocatorData } from './types';
+
+describe('functionCheckMatchNamePattern', () => {
+  it('should pass if function matches pattern', () => {
+    const sourceFile = createSourceFile(`function testFunc() {}`);
+    const data: FunctionLocatorData = {
+      type: 'FunctionLocator',
+      functions: getFunctions(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = functionCheckMatchNamePattern(data, /^test/, false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if function does not match pattern', () => {
+    const sourceFile = createSourceFile(`function myFunc() {}`);
+    const data: FunctionLocatorData = {
+      type: 'FunctionLocator',
+      functions: getFunctions(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = functionCheckMatchNamePattern(data, /^test/, false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/functions/functionCheckMatchNamePattern.ts

@@ -0,0 +1,18 @@
+import * as ts from 'typescript';
+import { sharedCheckMatchNamePattern } from '../shared/sharedCheckMatchNamePattern';
+import type { RuleResult } from '../types';
+import type { FunctionLocatorData } from './types';
+
+export function functionCheckMatchNamePattern(
+  locator: FunctionLocatorData,
+  pattern: string | RegExp,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckMatchNamePattern(
+    locator.functions,
+    (f) => (f.name && ts.isIdentifier(f.name) ? f.name.text : undefined),
+    'Function',
+    pattern,
+    isNot,
+  );
+}

package/src/core/functions/locateFunctions.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getFunctions } from '../testUtils';
+import { locateFunctions } from './locateFunctions';
+
+describe('locateFunctions', () => {
+  it('should filter functions by matchNamePattern', () => {
+    const file1 = createSourceFile('function a() {}; function b() {}');
+    const functions = getFunctions(file1);
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const result = locateFunctions(functions, {} as any, {
+      matchNamePattern: 'a',
+    });
+    expect(result.functions.length).toBe(1);
+    expect(result.functions[0].name?.text).toBe('a');
+  });
+});

package/src/core/functions/locateFunctions.ts

@@ -0,0 +1,47 @@
+import * as ts from 'typescript';
+import type { FunctionLocatorData, FunctionQueryOptions } from './types';
+
+export function locateFunctions(
+  functions: ts.FunctionLikeDeclaration[],
+  program: ts.Program,
+  options?: FunctionQueryOptions,
+): FunctionLocatorData {
+  let filtered = functions;
+
+  if (options?.inFolder) {
+    filtered = filtered.filter((f) => {
+      const sourceFile = f.getSourceFile
+        ? f.getSourceFile()
+        : f.parent
+          ? ts.getSourceFileOfNode(f)
+          : undefined;
+      if (!sourceFile) return false;
+      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);
+    });
+  }
+
+  return {
+    type: 'FunctionLocator',
+    functions: filtered,
+    program,
+  };
+}

package/src/core/functions/types.ts

@@ -0,0 +1,13 @@
+import type * as ts from 'typescript';
+
+export interface FunctionLocatorData {
+  type: 'FunctionLocator';
+  functions: ts.FunctionLikeDeclaration[];
+  program: ts.Program;
+}
+
+export interface FunctionQueryOptions {
+  inFolder?: string;
+  matchNamePattern?: string | RegExp;
+  isTopLevel?: boolean;
+}

package/src/core/layers/checkLayeredArchitecture.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { checkLayeredArchitecture } from './checkLayeredArchitecture';
+import { createLayeredArchitecture } from './createLayeredArchitecture';
+
+describe('checkLayeredArchitecture', () => {
+  it('should evaluate all assertions and return true if none fail', () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const data = createLayeredArchitecture([], {} as any);
+    data.assertions.push(() => []); // returns no violations
+    const result = checkLayeredArchitecture(data);
+    expect(result.pass).toBe(true);
+    expect(result.message()).toBe('');
+  });
+
+  it('should return false if any assertion yields violations', () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const data = createLayeredArchitecture([], {} as any);
+    data.assertions.push(() => ['Layer violation!']);
+    const result = checkLayeredArchitecture(data);
+    expect(result.pass).toBe(false);
+    expect(result.message()).toBe('Layer violation!');
+  });
+});

package/src/core/layers/checkLayeredArchitecture.ts

@@ -0,0 +1,15 @@
+import type { RuleResult } from '../types';
+import type { LayeredArchitectureData } from './types';
+
+export function checkLayeredArchitecture(
+  data: LayeredArchitectureData,
+): RuleResult {
+  const violations: string[] = [];
+  for (const assertion of data.assertions) {
+    violations.push(...assertion(data.files));
+  }
+  return {
+    pass: violations.length === 0,
+    message: () => violations.join('\n'),
+  };
+}

package/src/core/layers/createLayeredArchitecture.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { createLayeredArchitecture } from './createLayeredArchitecture';
+
+describe('createLayeredArchitecture', () => {
+  it('should initialize a LayeredArchitectureData object', () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const data = createLayeredArchitecture([], {} as any);
+    expect(data.type).toBe('LayeredArchitecture');
+    expect(data.files).toEqual([]);
+    expect(data.layers.size).toBe(0);
+    expect(data.assertions.length).toBe(0);
+  });
+});

package/src/core/layers/createLayeredArchitecture.ts

@@ -0,0 +1,15 @@
+import type * as ts from 'typescript';
+import type { LayeredArchitectureData } from './types';
+
+export function createLayeredArchitecture(
+  files: ts.SourceFile[],
+  program: ts.Program,
+): LayeredArchitectureData {
+  return {
+    type: 'LayeredArchitecture',
+    files,
+    layers: new Map<string, string>(),
+    assertions: [],
+    program,
+  };
+}

package/src/core/layers/getLayerDependencies.ts

@@ -0,0 +1,45 @@
+import * as ts from 'typescript';
+
+export function getLayerDependencies(
+  sourceFile: ts.SourceFile,
+  program: ts.Program,
+): string[] {
+  const dependencies: string[] = [];
+  const compilerOptions = 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?.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?.resolvedFileName &&
+        !resolved.resolvedModule.isExternalLibraryImport
+      ) {
+        dependencies.push(resolved.resolvedModule.resolvedFileName);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return dependencies;
+}

package/src/core/layers/layer.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import { createLayeredArchitecture } from './createLayeredArchitecture';
+import { layer } from './layer';
+
+describe('layer', () => {
+  it('should add a layer pattern to the architecture data', () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    let data = createLayeredArchitecture([], {} as any);
+    data = layer(data, 'Domain', 'src/domain');
+    expect(data.layers.get('Domain')).toBe('src/domain');
+  });
+});

package/src/core/layers/layer.ts

@@ -0,0 +1,10 @@
+import type { LayeredArchitectureData } from './types';
+
+export function layer(
+  data: LayeredArchitectureData,
+  name: string,
+  folderPattern: string,
+): LayeredArchitectureData {
+  data.layers.set(name, folderPattern);
+  return data;
+}

package/src/core/layers/layerShouldNotBeAccessedByAnyLayer.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { createLayeredArchitecture } from './createLayeredArchitecture';
+import { layer } from './layer';
+import { layerShouldNotBeAccessedByAnyLayer } from './layerShouldNotBeAccessedByAnyLayer';
+
+describe('layerShouldNotBeAccessedByAnyLayer', () => {
+  it('should push an assertion to the data', () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    let data = createLayeredArchitecture([], {} as any);
+    data = layer(data, 'Domain', 'src/domain');
+    data = layerShouldNotBeAccessedByAnyLayer(data, 'Domain');
+    expect(data.assertions.length).toBe(1);
+  });
+});

package/src/core/layers/layerShouldNotBeAccessedByAnyLayer.ts

@@ -0,0 +1,40 @@
+import { getLayerDependencies } from './getLayerDependencies';
+import type { LayeredArchitectureData } from './types';
+
+export function layerShouldNotBeAccessedByAnyLayer(
+  data: LayeredArchitectureData,
+  targetLayer: string,
+): LayeredArchitectureData {
+  if (!data.layers.has(targetLayer)) {
+    throw new Error(`Layer ${targetLayer} is not defined`);
+  }
+
+  data.assertions.push((files) => {
+    const violations: string[] = [];
+    // biome-ignore lint/style/noNonNullAssertion: Safe map lookup
+    const targetPattern = data.layers.get(targetLayer)!;
+
+    for (const file of files) {
+      const filePath = file.fileName;
+      if (
+        !filePath.includes(`/${targetPattern}/`) &&
+        !filePath.includes(`\\${targetPattern}\\`)
+      ) {
+        const dependencies = getLayerDependencies(file, data.program);
+        const importsTarget = dependencies.some(
+          (dep) =>
+            dep.includes(`/${targetPattern}/`) ||
+            dep.includes(`\\${targetPattern}\\`),
+        );
+        if (importsTarget) {
+          violations.push(
+            `File ${filePath} accesses layer ${targetLayer} but it shouldn't.`,
+          );
+        }
+      }
+    }
+    return violations;
+  });
+
+  return data;
+}

package/src/core/layers/layerShouldOnlyBeAccessedBy.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { createLayeredArchitecture } from './createLayeredArchitecture';
+import { layer } from './layer';
+import { layerShouldOnlyBeAccessedBy } from './layerShouldOnlyBeAccessedBy';
+
+describe('layerShouldOnlyBeAccessedBy', () => {
+  it('should push an assertion to the data', () => {
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    let data = createLayeredArchitecture([], {} as any);
+    data = layer(data, 'Domain', 'src/domain');
+    data = layer(data, 'Infra', 'src/infra');
+    data = layerShouldOnlyBeAccessedBy(data, 'Domain', ['Infra']);
+    expect(data.assertions.length).toBe(1);
+  });
+});

package/src/core/layers/layerShouldOnlyBeAccessedBy.ts

@@ -0,0 +1,48 @@
+import { getLayerDependencies } from './getLayerDependencies';
+import type { LayeredArchitectureData } from './types';
+
+export function layerShouldOnlyBeAccessedBy(
+  data: LayeredArchitectureData,
+  targetLayer: string,
+  allowedLayers: string[],
+): LayeredArchitectureData {
+  if (!data.layers.has(targetLayer)) {
+    throw new Error(`Layer ${targetLayer} is not defined`);
+  }
+
+  data.assertions.push((files) => {
+    const violations: string[] = [];
+    // biome-ignore lint/style/noNonNullAssertion: Safe map lookup
+    const targetPattern = data.layers.get(targetLayer)!;
+    // biome-ignore lint/style/noNonNullAssertion: Safe map lookup
+    const allowedPatterns = allowedLayers.map((l) => data.layers.get(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 = getLayerDependencies(file, data.program);
+        const importsTarget = dependencies.some(
+          (dep) =>
+            dep.includes(`/${targetPattern}/`) ||
+            dep.includes(`\\${targetPattern}\\`),
+        );
+        if (importsTarget) {
+          violations.push(
+            `File ${filePath} accesses layer ${targetLayer} but only ${allowedLayers.join(', ')} are allowed.`,
+          );
+        }
+      }
+    }
+    return violations;
+  });
+
+  return data;
+}

package/src/core/layers/types.ts

@@ -0,0 +1,9 @@
+import type * as ts from 'typescript';
+
+export interface LayeredArchitectureData {
+  type: 'LayeredArchitecture';
+  files: ts.SourceFile[];
+  layers: Map<string, string>;
+  assertions: Array<(files: ts.SourceFile[]) => string[]>;
+  program: ts.Program;
+}

package/src/core/metrics/calculateCyclomaticComplexity.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getFunctions } from '../testUtils';
+import { calculateCyclomaticComplexity } from './calculateCyclomaticComplexity';
+
+describe('calculateCyclomaticComplexity', () => {
+  it('should return 1 for a simple function', () => {
+    const sourceFile = createSourceFile('function simple() { return 1; }');
+    const fns = getFunctions(sourceFile);
+    expect(calculateCyclomaticComplexity(fns[0])).toBe(1);
+  });
+
+  it('should calculate higher complexity for branches', () => {
+    const sourceFile = createSourceFile(`
+      function complex(a) {
+        if (a) return 1;
+        if (!a) return 2;
+        return a ? 3 : 4;
+      }
+    `);
+    const fns = getFunctions(sourceFile);
+    expect(calculateCyclomaticComplexity(fns[0])).toBe(4);
+  });
+});

package/src/core/metrics/calculateCyclomaticComplexity.ts

@@ -0,0 +1,36 @@
+import * as ts from 'typescript';
+
+export function calculateCyclomaticComplexity(node: ts.Node): number {
+  let complexity = 1;
+
+  const visit = (n: ts.Node) => {
+    switch (n.kind) {
+      case ts.SyntaxKind.IfStatement:
+      case ts.SyntaxKind.ForStatement:
+      case ts.SyntaxKind.ForInStatement:
+      case ts.SyntaxKind.ForOfStatement:
+      case ts.SyntaxKind.WhileStatement:
+      case ts.SyntaxKind.DoStatement:
+      case ts.SyntaxKind.CaseClause:
+      case ts.SyntaxKind.CatchClause:
+      case ts.SyntaxKind.ConditionalExpression:
+        complexity++;
+        break;
+      case ts.SyntaxKind.BinaryExpression: {
+        const binary = n as ts.BinaryExpression;
+        if (
+          binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+          binary.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
+          binary.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken
+        ) {
+          complexity++;
+        }
+        break;
+      }
+    }
+    ts.forEachChild(n, visit);
+  };
+
+  ts.forEachChild(node, visit);
+  return complexity;
+}

package/src/core/metrics/calculateMaintainabilityIndex.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getFunctions } from '../testUtils';
+import { calculateMaintainabilityIndex } from './calculateMaintainabilityIndex';
+
+describe('calculateMaintainabilityIndex', () => {
+  it('should return a high index for a simple function', () => {
+    const sourceFile = createSourceFile('function simple() { return 1; }');
+    const fns = getFunctions(sourceFile);
+    expect(calculateMaintainabilityIndex(fns[0])).toBeGreaterThan(80);
+  });
+
+  it('should return a lower index for a complex function', () => {
+    const sourceFile = createSourceFile(`
+      function complex(a, b, c) {
+        if (a) {
+          if (b) {
+            for (let i = 0; i < 10; i++) {
+               console.log(c);
+            }
+          }
+        }
+        switch(a) {
+          case 1: return 1;
+          case 2: return 2;
+        }
+      }
+    `);
+    const fns = getFunctions(sourceFile);
+    const complexMI = calculateMaintainabilityIndex(fns[0]);
+    const simpleSourceFile = createSourceFile(
+      'function simple() { return 1; }',
+    );
+    const simpleMI = calculateMaintainabilityIndex(
+      getFunctions(simpleSourceFile)[0],
+    );
+    expect(complexMI).toBeLessThan(simpleMI);
+  });
+});

package/src/core/metrics/calculateMaintainabilityIndex.ts

@@ -0,0 +1,47 @@
+import * as ts from 'typescript';
+import { calculateCyclomaticComplexity } from './calculateCyclomaticComplexity';
+
+export function calculateMaintainabilityIndex(node: ts.Node): number {
+  let operators = 0;
+  let operands = 0;
+  const uniqueOperators = new Set<number>();
+  const uniqueOperands = new Set<string>();
+  let linesOfCode = 1;
+
+  const sourceFile = node.getSourceFile();
+  if (sourceFile) {
+    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+    linesOfCode = end.line - start.line + 1;
+  }
+
+  const visit = (n: ts.Node) => {
+    if (
+      ts.isBinaryExpression(n) ||
+      ts.isPrefixUnaryExpression(n) ||
+      ts.isPostfixUnaryExpression(n)
+    ) {
+      operators++;
+      uniqueOperators.add(n.kind);
+    } else if (ts.isIdentifier(n) || ts.isLiteralExpression(n)) {
+      operands++;
+      uniqueOperands.add(n.getText(sourceFile));
+    }
+    ts.forEachChild(n, visit);
+  };
+
+  visit(node);
+
+  const N = operators + operands;
+  const n = uniqueOperators.size + uniqueOperands.size;
+  const V = n === 0 ? 0 : N * Math.log2(n);
+  const CC = calculateCyclomaticComplexity(node);
+
+  const mi = Math.max(
+    0,
+    ((171 - 5.2 * Math.log(V || 1) - 0.23 * CC - 16.2 * Math.log(linesOfCode)) *
+      100) /
+      171,
+  );
+  return mi;
+}

package/src/core/project/parseProject.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { parseProject } from './parseProject';
+
+describe('parseProject', () => {
+  it('should parse the current project correctly', () => {
+    // Running from within vitest-arch, it should pick up the tsconfig
+    const project = parseProject();
+    expect(project).toHaveProperty('getFiles');
+    expect(project).toHaveProperty('getClasses');
+    expect(project).toHaveProperty('getFunctions');
+    expect(project).toHaveProperty('layeredArchitecture');
+    expect(project).toHaveProperty('getSlices');
+
+    // Verify it can get its own files
+    const coreFiles = project.getFiles({ inFolder: 'core' });
+    expect(coreFiles.files.length).toBeGreaterThan(0);
+    expect(coreFiles.type).toBe('FileLocator');
+  });
+});