@archest/vitest 1.0.0 → 1.0.1

package/src/core/classes/types.ts

@@ -0,0 +1,16 @@
+import type * as ts from 'typescript';
+
+export interface ClassLocatorData {
+  type: 'ClassLocator';
+  classes: ts.ClassDeclaration[];
+  program: ts.Program;
+}
+
+export interface ClassQueryOptions {
+  inFolder?: string;
+  matchNamePattern?: string | RegExp;
+  withDecorator?: string;
+  extending?: string;
+  implementing?: string;
+  havingModifier?: string;
+}

package/src/core/files/checkDependOnFilesInFolder.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'vitest';
+
+describe('checkDependOnFilesInFolder', () => {
+  it('is thoroughly integration tested in architecture.test.ts', () => {
+    expect(true).toBe(true);
+  });
+});

package/src/core/files/checkDependOnFilesInFolder.ts

@@ -0,0 +1,36 @@
+import type { RuleResult } from '../types';
+import { getFileDependencies } from './getFileDependencies';
+import type { FileLocatorData } from './types';
+
+export function checkDependOnFilesInFolder(
+  locator: FileLocatorData,
+  targetFolder: string,
+  isNot: boolean,
+): RuleResult {
+  const violations: string[] = [];
+
+  for (const file of locator.files) {
+    const dependencies = getFileDependencies(file, locator.program);
+
+    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'),
+  };
+}

package/src/core/files/fileCheckBeFreeOfCycles.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'vitest';
+
+describe('fileCheckBeFreeOfCycles', () => {
+  it('is thoroughly integration tested in architecture.test.ts', () => {
+    expect(true).toBe(true);
+  });
+});

package/src/core/files/fileCheckBeFreeOfCycles.ts

@@ -0,0 +1,72 @@
+import type { RuleResult } from '../types';
+import { getFileDependencies } from './getFileDependencies';
+import type { FileLocatorData } from './types';
+
+export function fileCheckBeFreeOfCycles(
+  locator: FileLocatorData,
+  isNot: boolean,
+): RuleResult {
+  const violations: string[] = [];
+  const targetedFilePaths = new Set<string>(
+    locator.files.map((f) => f.fileName),
+  );
+  const graph = new Map<string, string[]>();
+
+  for (const file of locator.files) {
+    const filePath = file.fileName;
+    const dependencies = getFileDependencies(file, locator.program).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'),
+  };
+}

package/src/core/files/fileCheckHaveMaxCyclomaticComplexity.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import { fileCheckHaveMaxCyclomaticComplexity } from './fileCheckHaveMaxCyclomaticComplexity';
+
+describe('fileCheckHaveMaxCyclomaticComplexity', () => {
+  it('should exist and be callable', () => {
+    expect(typeof fileCheckHaveMaxCyclomaticComplexity).toBe('function');
+  });
+});

package/src/core/files/fileCheckHaveMaxCyclomaticComplexity.ts

@@ -0,0 +1,35 @@
+import * as ts from 'typescript';
+import { calculateCyclomaticComplexity } from '../metrics/calculateCyclomaticComplexity';
+import { sharedCheckHaveMaxCyclomaticComplexity } from '../shared/sharedCheckHaveMaxCyclomaticComplexity';
+import type { RuleResult } from '../types';
+import type { FileLocatorData } from './types';
+
+export function fileCheckHaveMaxCyclomaticComplexity(
+  locator: FileLocatorData,
+  max: number,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckHaveMaxCyclomaticComplexity(
+    locator.files,
+    (f) => f.fileName,
+    (file) => {
+      let complexity = 0;
+      const visit = (node: ts.Node) => {
+        if (
+          ts.isFunctionDeclaration(node) ||
+          ts.isMethodDeclaration(node) ||
+          ts.isArrowFunction(node) ||
+          ts.isFunctionExpression(node)
+        ) {
+          complexity += calculateCyclomaticComplexity(node);
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(file);
+      return complexity;
+    },
+    'File',
+    max,
+    isNot,
+  );
+}

package/src/core/files/fileCheckHaveMaxExportedFunctions.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile } from '../testUtils';
+import { fileCheckHaveMaxExportedFunctions } from './fileCheckHaveMaxExportedFunctions';
+import type { FileLocatorData } from './types';
+
+describe('fileCheckHaveMaxExportedFunctions', () => {
+  it('should pass if under max exports', () => {
+    const sourceFile = createSourceFile(`export function a() {}`);
+    const data: FileLocatorData = {
+      type: 'FileLocator',
+      files: [sourceFile],
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = fileCheckHaveMaxExportedFunctions(data, 1, false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if over max exports', () => {
+    const sourceFile = createSourceFile(
+      `export function a() {} export function b() {}`,
+    );
+    const data: FileLocatorData = {
+      type: 'FileLocator',
+      files: [sourceFile],
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = fileCheckHaveMaxExportedFunctions(data, 1, false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/files/fileCheckHaveMaxExportedFunctions.ts

@@ -0,0 +1,45 @@
+import * as ts from 'typescript';
+import type { RuleResult } from '../types';
+import type { FileLocatorData } from './types';
+
+export function fileCheckHaveMaxExportedFunctions(
+  locator: FileLocatorData,
+  max: number,
+  isNot: boolean,
+): RuleResult {
+  const violations: string[] = [];
+  for (const file of locator.files) {
+    let exportedFuncCount = 0;
+
+    ts.forEachChild(file, (node) => {
+      if (ts.isFunctionDeclaration(node)) {
+        const modifiers = ts.canHaveModifiers(node)
+          ? ts.getModifiers(node)
+          : undefined;
+        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          exportedFuncCount++;
+        }
+      }
+    });
+
+    const exceeds = exportedFuncCount > max;
+
+    if (isNot && exceeds) {
+      violations.push(
+        `File ${file.fileName} has ${exportedFuncCount} exported functions, which exceeds the maximum of ${max}, but it shouldn't.`,
+      );
+    } else if (!isNot && exceeds) {
+      violations.push(
+        `File ${file.fileName} has ${exportedFuncCount} exported functions, which exceeds the maximum of ${max}.`,
+      );
+    }
+  }
+  return {
+    pass: isNot ? violations.length > 0 : violations.length === 0,
+    message: () =>
+      violations.join('\n') ||
+      (isNot
+        ? 'Expected some files to exceed maximum exported functions, but none did.'
+        : ''),
+  };
+}

package/src/core/files/fileCheckHaveMinMaintainabilityIndex.test.ts

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import { fileCheckHaveMinMaintainabilityIndex } from './fileCheckHaveMinMaintainabilityIndex';
+
+describe('fileCheckHaveMinMaintainabilityIndex', () => {
+  it('should exist and be callable', () => {
+    expect(typeof fileCheckHaveMinMaintainabilityIndex).toBe('function');
+  });
+});

package/src/core/files/fileCheckHaveMinMaintainabilityIndex.ts

@@ -0,0 +1,19 @@
+import { calculateMaintainabilityIndex } from '../metrics/calculateMaintainabilityIndex';
+import { sharedCheckHaveMinMaintainabilityIndex } from '../shared/sharedCheckHaveMinMaintainabilityIndex';
+import type { RuleResult } from '../types';
+import type { FileLocatorData } from './types';
+
+export function fileCheckHaveMinMaintainabilityIndex(
+  locator: FileLocatorData,
+  min: number,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckHaveMinMaintainabilityIndex(
+    locator.files,
+    (f) => f.fileName,
+    calculateMaintainabilityIndex,
+    'File',
+    min,
+    isNot,
+  );
+}

package/src/core/files/fileCheckMatchNamePattern.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile } from '../testUtils';
+import { fileCheckMatchNamePattern } from './fileCheckMatchNamePattern';
+import type { FileLocatorData } from './types';
+
+describe('fileCheckMatchNamePattern', () => {
+  it('should pass if filename matches', () => {
+    const sourceFile = createSourceFile(`// code`, 'src/core/test.ts');
+    const data: FileLocatorData = {
+      type: 'FileLocator',
+      files: [sourceFile],
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = fileCheckMatchNamePattern(data, /.*\.ts$/, false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if filename does not match', () => {
+    const sourceFile = createSourceFile(`// code`, 'src/core/test.js');
+    const data: FileLocatorData = {
+      type: 'FileLocator',
+      files: [sourceFile],
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = fileCheckMatchNamePattern(data, /.*\.ts$/, false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/files/fileCheckMatchNamePattern.ts

@@ -0,0 +1,17 @@
+import { sharedCheckMatchNamePattern } from '../shared/sharedCheckMatchNamePattern';
+import type { RuleResult } from '../types';
+import type { FileLocatorData } from './types';
+
+export function fileCheckMatchNamePattern(
+  locator: FileLocatorData,
+  pattern: string | RegExp,
+  isNot: boolean,
+): RuleResult {
+  return sharedCheckMatchNamePattern(
+    locator.files,
+    (f) => f.fileName,
+    'File',
+    pattern,
+    isNot,
+  );
+}

package/src/core/files/getFileDependencies.ts

@@ -0,0 +1,43 @@
+import * as ts from 'typescript';
+
+export function getFileDependencies(
+  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) {
+        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?.resolvedFileName) {
+        if (!resolved.resolvedModule.isExternalLibraryImport) {
+          dependencies.push(resolved.resolvedModule.resolvedFileName);
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+
+  visit(sourceFile);
+  return dependencies;
+}

package/src/core/files/locateFiles.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile } from '../testUtils';
+import { locateFiles } from './locateFiles';
+
+describe('locateFiles', () => {
+  it('should filter files by inFolder query', () => {
+    const file1 = createSourceFile('function a() {}', 'src/domain/file1.ts');
+    const file2 = createSourceFile('function b() {}', 'src/infra/file2.ts');
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const result = locateFiles([file1, file2], {} as any, {
+      inFolder: 'domain',
+    });
+    expect(result.files.length).toBe(1);
+    expect(result.files[0].fileName).toBe('src/domain/file1.ts');
+  });
+
+  it('should filter files by matchNamePattern query', () => {
+    const file1 = createSourceFile('function a() {}', 'src/domain/file1.ts');
+    const file2 = createSourceFile(
+      'function b() {}',
+      'src/domain/file2.spec.ts',
+    );
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const result = locateFiles([file1, file2], {} as any, {
+      matchNamePattern: /\.spec\.ts$/,
+    });
+    expect(result.files.length).toBe(1);
+    expect(result.files[0].fileName).toBe('src/domain/file2.spec.ts');
+  });
+});

package/src/core/files/locateFiles.ts

@@ -0,0 +1,31 @@
+import type * as ts from 'typescript';
+import type { FileLocatorData, FileQueryOptions } from './types';
+
+export function locateFiles(
+  sourceFiles: ts.SourceFile[],
+  program: ts.Program,
+  options?: FileQueryOptions,
+): FileLocatorData {
+  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));
+  }
+
+  return {
+    type: 'FileLocator',
+    files: filtered,
+    program,
+  };
+}

package/src/core/files/types.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+
+export interface FileLocatorData {
+  type: 'FileLocator';
+  files: ts.SourceFile[];
+  program: ts.Program;
+}
+
+export interface FileQueryOptions {
+  inFolder?: string;
+  matchNamePattern?: string | RegExp;
+}

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

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getFunctions } from '../testUtils';
+import { functionCheckHaveExplicitReturnType } from './functionCheckHaveExplicitReturnType';
+import type { FunctionLocatorData } from './types';
+
+describe('functionCheckHaveExplicitReturnType', () => {
+  it('should pass if function has explicit return type', () => {
+    const sourceFile = createSourceFile(`function myFunc(): void {}`);
+    const data: FunctionLocatorData = {
+      type: 'FunctionLocator',
+      functions: getFunctions(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = functionCheckHaveExplicitReturnType(data, false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if function lacks explicit return type', () => {
+    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 = functionCheckHaveExplicitReturnType(data, false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/functions/functionCheckHaveExplicitReturnType.ts

@@ -0,0 +1,29 @@
+import * as ts from 'typescript';
+import type { RuleResult } from '../types';
+import type { FunctionLocatorData } from './types';
+
+export function functionCheckHaveExplicitReturnType(
+  locator: FunctionLocatorData,
+  isNot: boolean,
+): RuleResult {
+  const violations: string[] = [];
+  for (const f of locator.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'),
+  };
+}

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

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import { functionCheckHaveMaxCyclomaticComplexity } from './functionCheckHaveMaxCyclomaticComplexity';
+
+describe('functionCheckHaveMaxCyclomaticComplexity', () => {
+  it('should exist and be callable', () => {
+    expect(typeof functionCheckHaveMaxCyclomaticComplexity).toBe('function');
+  });
+});

package/src/core/functions/functionCheckHaveMaxCyclomaticComplexity.ts

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

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

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import { functionCheckHaveMinMaintainabilityIndex } from './functionCheckHaveMinMaintainabilityIndex';
+
+describe('functionCheckHaveMinMaintainabilityIndex', () => {
+  it('should exist and be callable', () => {
+    expect(typeof functionCheckHaveMinMaintainabilityIndex).toBe('function');
+  });
+});

package/src/core/functions/functionCheckHaveMinMaintainabilityIndex.ts

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

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

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getFunctions } from '../testUtils';
+import { functionCheckHaveModifier } from './functionCheckHaveModifier';
+import type { FunctionLocatorData } from './types';
+
+describe('functionCheckHaveModifier', () => {
+  it('should pass if function has modifier', () => {
+    const sourceFile = createSourceFile(`export 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 = functionCheckHaveModifier(data, 'export', false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if function lacks modifier', () => {
+    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 = functionCheckHaveModifier(data, 'export', false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/functions/functionCheckHaveModifier.ts

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