@archest/vitest 1.0.0 → 1.0.1

package/src/core/project/parseProject.ts

@@ -0,0 +1,216 @@
+import { dirname } from 'node:path';
+import * as ts from 'typescript';
+import { locateClasses } from '../classes/locateClasses';
+import type { ClassQueryOptions } from '../classes/types';
+import { locateFiles } from '../files/locateFiles';
+import type { FileQueryOptions } from '../files/types';
+import { locateFunctions } from '../functions/locateFunctions';
+import type { FunctionQueryOptions } from '../functions/types';
+import { checkLayeredArchitecture } from '../layers/checkLayeredArchitecture';
+import { createLayeredArchitecture } from '../layers/createLayeredArchitecture';
+import { layer } from '../layers/layer';
+import { layerShouldNotBeAccessedByAnyLayer } from '../layers/layerShouldNotBeAccessedByAnyLayer';
+import { layerShouldOnlyBeAccessedBy } from '../layers/layerShouldOnlyBeAccessedBy';
+import { locateProperties } from '../properties/locateProperties';
+import type { PropertyQueryOptions } from '../properties/types';
+import { locateSlices } from '../slices/locateSlices';
+
+export function parseProject(options: { tsConfigFilePath?: string } = {}) {
+  let compilerOptions: ts.CompilerOptions = {};
+  const configPath =
+    options.tsConfigFilePath ||
+    ts.findConfigFile(process.cwd(), ts.sys.fileExists, 'tsconfig.json');
+
+  let program: ts.Program;
+
+  if (configPath) {
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    const parsedCommandLine = ts.parseJsonConfigFileContent(
+      configFile.config,
+      ts.sys,
+      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;
+
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic require
+    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 {
+            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,
+      );
+    };
+
+    program = ts.createProgram({
+      rootNames: parsedCommandLine.fileNames,
+      options: compilerOptions,
+      host: host,
+    });
+
+    // Force the TypeScript compiler to bind the AST and populate .parent pointers
+    program.getTypeChecker();
+  } else {
+    throw new Error('Could not find tsconfig.json');
+  }
+
+  const getSourceFiles = () =>
+    program
+      .getSourceFiles()
+      .filter(
+        (sf) => !sf.isDeclarationFile && !sf.fileName.includes('node_modules'),
+      );
+
+  return {
+    getFiles: (queryOptions?: FileQueryOptions) => {
+      return locateFiles(getSourceFiles(), program, queryOptions);
+    },
+
+    getClasses: (queryOptions?: ClassQueryOptions) => {
+      const allClasses: ts.ClassDeclaration[] = [];
+      for (const sf of getSourceFiles()) {
+        const visit = (node: ts.Node) => {
+          if (ts.isClassDeclaration(node)) {
+            allClasses.push(node);
+          }
+          ts.forEachChild(node, visit);
+        };
+        visit(sf);
+      }
+      return locateClasses(allClasses, program, queryOptions);
+    },
+
+    layeredArchitecture: () => {
+      let data = createLayeredArchitecture(getSourceFiles(), program);
+      const api = {
+        layer: (name: string, folderPattern: string) => {
+          data = layer(data, name, folderPattern);
+          return api;
+        },
+        whereLayer: (name: string) => {
+          return {
+            shouldNotBeAccessedByAnyLayer: () => {
+              data = layerShouldNotBeAccessedByAnyLayer(data, name);
+              return api;
+            },
+            shouldOnlyBeAccessedBy: (...allowedLayers: string[]) => {
+              data = layerShouldOnlyBeAccessedBy(data, name, allowedLayers);
+              return api;
+            },
+          };
+        },
+        check: () => checkLayeredArchitecture(data),
+        get data() {
+          return data;
+        },
+      };
+      return api;
+    },
+
+    getFunctions: (queryOptions?: FunctionQueryOptions) => {
+      const allFunctions: ts.FunctionLikeDeclaration[] = [];
+      for (const sf of getSourceFiles()) {
+        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 locateFunctions(allFunctions, program, queryOptions);
+    },
+
+    getProperties: (queryOptions?: PropertyQueryOptions) => {
+      const allProperties: ts.PropertyDeclaration[] = [];
+      for (const sf of getSourceFiles()) {
+        const visit = (node: ts.Node) => {
+          if (ts.isPropertyDeclaration(node)) {
+            allProperties.push(node);
+          }
+          ts.forEachChild(node, visit);
+        };
+        visit(sf);
+      }
+      return locateProperties(allProperties, program, queryOptions);
+    },
+
+    getSlices: (pattern: string) => {
+      return locateSlices(getSourceFiles(), program, pattern);
+    },
+  };
+}

package/src/core/properties/locateProperties.test.ts

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+import { describe, expect, it } from 'vitest';
+import { createSourceFile } from '../testUtils';
+import { locateProperties } from './locateProperties';
+
+describe('locateProperties', () => {
+  it('should return all properties if no query options', () => {
+    const file1 = createSourceFile('class A { prop: string; }');
+    const properties: ts.PropertyDeclaration[] = [];
+    const visit = (node: ts.Node) => {
+      if (ts.isPropertyDeclaration(node)) properties.push(node);
+      ts.forEachChild(node, visit);
+    };
+    visit(file1);
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const result = locateProperties(properties, {} as any);
+    expect(result.properties.length).toBe(1);
+  });
+});

package/src/core/properties/locateProperties.ts

@@ -0,0 +1,41 @@
+import * as ts from 'typescript';
+import type { PropertyLocatorData, PropertyQueryOptions } from './types';
+
+export function locateProperties(
+  properties: ts.PropertyDeclaration[],
+  program: ts.Program,
+  options?: PropertyQueryOptions,
+): PropertyLocatorData {
+  let filtered = properties;
+
+  if (options?.inFolder) {
+    filtered = filtered.filter((p) => {
+      const sourceFile = p.getSourceFile
+        ? p.getSourceFile()
+        : p.parent
+          ? ts.getSourceFileOfNode(p)
+          : 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((p) => {
+      return ts.isIdentifier(p.name) && regex.test(p.name.text);
+    });
+  }
+
+  return {
+    type: 'PropertyLocator',
+    properties: filtered,
+    program,
+  };
+}

package/src/core/properties/propertyCheckBeReadonly.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getProperties } from '../testUtils';
+import { propertyCheckBeReadonly } from './propertyCheckBeReadonly';
+import type { PropertyLocatorData } from './types';
+
+describe('propertyCheckBeReadonly', () => {
+  it('should pass if properties are readonly', () => {
+    const sourceFile = createSourceFile(
+      `class MyClass { readonly prop: string; }`,
+    );
+    const data: PropertyLocatorData = {
+      type: 'PropertyLocator',
+      properties: getProperties(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = propertyCheckBeReadonly(data, false);
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if properties are not readonly', () => {
+    const sourceFile = createSourceFile(`class MyClass { prop: string; }`);
+    const data: PropertyLocatorData = {
+      type: 'PropertyLocator',
+      properties: getProperties(sourceFile),
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      program: {} as any,
+    };
+    const result = propertyCheckBeReadonly(data, false);
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/properties/propertyCheckBeReadonly.ts

@@ -0,0 +1,27 @@
+import * as ts from 'typescript';
+import type { RuleResult } from '../types';
+import type { PropertyLocatorData } from './types';
+
+export function propertyCheckBeReadonly(
+  locator: PropertyLocatorData,
+  isNot: boolean,
+): RuleResult {
+  const violations: string[] = [];
+  for (const p of locator.properties) {
+    const name = ts.isIdentifier(p.name) ? p.name.text : 'Anonymous Property';
+    const modifiers = ts.canHaveModifiers(p) ? ts.getModifiers(p) : undefined;
+    const matches = 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/properties/types.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+
+export interface PropertyLocatorData {
+  type: 'PropertyLocator';
+  properties: ts.PropertyDeclaration[];
+  program: ts.Program;
+}
+
+export interface PropertyQueryOptions {
+  inFolder?: string;
+  matchNamePattern?: string | RegExp;
+}

package/src/core/shared/sharedCheckHaveMaxCyclomaticComplexity.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { sharedCheckHaveMaxCyclomaticComplexity } from './sharedCheckHaveMaxCyclomaticComplexity';
+
+describe('sharedCheckHaveMaxCyclomaticComplexity', () => {
+  it('should pass if complexity is within limits', () => {
+    const items = [{ name: 'A', complexity: 5 }];
+    const result = sharedCheckHaveMaxCyclomaticComplexity(
+      items,
+      (i) => i.name,
+      (i) => i.complexity,
+      'Item',
+      10,
+      false,
+    );
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if complexity exceeds limits', () => {
+    const items = [{ name: 'A', complexity: 15 }];
+    const result = sharedCheckHaveMaxCyclomaticComplexity(
+      items,
+      (i) => i.name,
+      (i) => i.complexity,
+      'Item',
+      10,
+      false,
+    );
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/shared/sharedCheckHaveMaxCyclomaticComplexity.ts

@@ -0,0 +1,23 @@
+import { ruleBuilder } from '../utils/ruleBuilder';
+
+export function sharedCheckHaveMaxCyclomaticComplexity<T>(
+  items: T[],
+  getName: (item: T) => string | undefined,
+  getComplexity: (item: T) => number,
+  label: string,
+  max: number,
+  isNot: boolean,
+) {
+  return ruleBuilder(items, isNot, (item) => {
+    const name = getName(item);
+    const complexity = getComplexity(item);
+    const exceeds = complexity > max;
+    const desc = `${label} ${name || 'Anonymous'}`;
+
+    return {
+      passes: !exceeds,
+      failMessage: `${desc} has a total cyclomatic complexity of ${complexity}, which exceeds the maximum of ${max}.`,
+      failNotMessage: `${desc} has a total cyclomatic complexity of ${complexity}, which exceeds the maximum of ${max}, but it shouldn't.`,
+    };
+  });
+}

package/src/core/shared/sharedCheckHaveMinMaintainabilityIndex.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { sharedCheckHaveMinMaintainabilityIndex } from './sharedCheckHaveMinMaintainabilityIndex';
+
+describe('sharedCheckHaveMinMaintainabilityIndex', () => {
+  it('should pass if MI is above limit', () => {
+    const items = [{ name: 'A', mi: 50 }];
+    const result = sharedCheckHaveMinMaintainabilityIndex(
+      items,
+      (i) => i.name,
+      (i) => i.mi,
+      'Item',
+      20,
+      false,
+    );
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if MI is below limit', () => {
+    const items = [{ name: 'A', mi: 10 }];
+    const result = sharedCheckHaveMinMaintainabilityIndex(
+      items,
+      (i) => i.name,
+      (i) => i.mi,
+      'Item',
+      20,
+      false,
+    );
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/shared/sharedCheckHaveMinMaintainabilityIndex.ts

@@ -0,0 +1,23 @@
+import { ruleBuilder } from '../utils/ruleBuilder';
+
+export function sharedCheckHaveMinMaintainabilityIndex<T>(
+  items: T[],
+  getName: (item: T) => string | undefined,
+  getMi: (item: T) => number,
+  label: string,
+  min: number,
+  isNot: boolean,
+) {
+  return ruleBuilder(items, isNot, (item) => {
+    const name = getName(item);
+    const mi = getMi(item);
+    const fallsBelow = mi < min;
+    const desc = `${label} ${name || 'Anonymous'}`;
+
+    return {
+      passes: !fallsBelow,
+      failMessage: `${desc} has a maintainability index of ${mi.toFixed(2)}, which falls below the minimum of ${min}.`,
+      failNotMessage: `${desc} has a maintainability index of ${mi.toFixed(2)}, which falls below the minimum of ${min}, but it shouldn't.`,
+    };
+  });
+}

package/src/core/shared/sharedCheckHaveModifier.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile, getClasses } from '../testUtils';
+import { sharedCheckHaveModifier } from './sharedCheckHaveModifier';
+
+describe('sharedCheckHaveModifier', () => {
+  it('should pass if node has the modifier', () => {
+    const sourceFile = createSourceFile('export class MyClass {}');
+    const classes = getClasses(sourceFile);
+    const result = sharedCheckHaveModifier(
+      classes,
+      (c) => c.name?.text,
+      'Class',
+      'export',
+      false,
+    );
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if node does not have the modifier', () => {
+    const sourceFile = createSourceFile('class MyClass {}');
+    const classes = getClasses(sourceFile);
+    const result = sharedCheckHaveModifier(
+      classes,
+      (c) => c.name?.text,
+      'Class',
+      'export',
+      false,
+    );
+    expect(result.pass).toBe(false);
+  });
+});

package/src/core/shared/sharedCheckHaveModifier.ts

@@ -0,0 +1,51 @@
+import * as ts from 'typescript';
+import { ruleBuilder } from '../utils/ruleBuilder';
+
+export function sharedCheckHaveModifier<T extends ts.Node>(
+  items: T[],
+  getName: (item: T) => string | undefined,
+  label: string,
+  modifierStr: string,
+  isNot: boolean,
+) {
+  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;
+    case 'async':
+      targetKind = ts.SyntaxKind.AsyncKeyword;
+      break;
+    case 'public':
+      targetKind = ts.SyntaxKind.PublicKeyword;
+      break;
+    case 'private':
+      targetKind = ts.SyntaxKind.PrivateKeyword;
+      break;
+    default:
+      throw new Error(`Modifier ${modifierStr} is not fully supported.`);
+  }
+
+  return ruleBuilder(items, isNot, (item) => {
+    const name = getName(item);
+    const modifiers = ts.canHaveModifiers(item)
+      ? ts.getModifiers(item)
+      : undefined;
+    const passes = modifiers
+      ? modifiers.some((m: ts.Modifier) => m.kind === targetKind)
+      : false;
+    const desc = `${label} ${name || 'Anonymous'}`;
+
+    return {
+      passes,
+      failMessage: `${desc} does not have modifier ${modifierStr}, but it should.`,
+      failNotMessage: `${desc} has modifier ${modifierStr}, but it shouldn't.`,
+    };
+  });
+}

package/src/core/shared/sharedCheckHaveNameMatchingFileName.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { sharedCheckHaveNameMatchingFileName } from './sharedCheckHaveNameMatchingFileName';
+
+describe('sharedCheckHaveNameMatchingFileName', () => {
+  it('should skip nodes without source files', () => {
+    // getFunctions actually provides a getSourceFile natively
+    // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+    const items = [{ parent: undefined } as any];
+    const result = sharedCheckHaveNameMatchingFileName(
+      items,
+      () => 'name',
+      'Item',
+      false,
+    );
+    expect(result.pass).toBe(true);
+  });
+});

package/src/core/shared/sharedCheckHaveNameMatchingFileName.ts

@@ -0,0 +1,36 @@
+import * as path from 'node:path';
+import * as ts from 'typescript';
+import { ruleBuilder } from '../utils/ruleBuilder';
+
+export function sharedCheckHaveNameMatchingFileName<T extends ts.Node>(
+  items: T[],
+  getName: (item: T) => string | undefined,
+  label: string,
+  isNot: boolean,
+) {
+  return ruleBuilder(items, isNot, (item) => {
+    const name = getName(item);
+    const sourceFile = item.getSourceFile
+      ? item.getSourceFile()
+      : item.parent
+        ? ts.getSourceFileOfNode(item)
+        : undefined;
+
+    if (!sourceFile) {
+      return { passes: true, failMessage: '', failNotMessage: '' };
+    }
+
+    const basename = path.basename(
+      sourceFile.fileName,
+      path.extname(sourceFile.fileName),
+    );
+    const passes = name === basename;
+    const desc = `${label} ${name || 'Anonymous'}`;
+
+    return {
+      passes,
+      failMessage: `${desc} does not have a name matching its filename ${basename}, but it should.`,
+      failNotMessage: `${desc} has a name matching its filename ${basename}, but it shouldn't.`,
+    };
+  });
+}

package/src/core/shared/sharedCheckMatchNamePattern.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { sharedCheckMatchNamePattern } from './sharedCheckMatchNamePattern';
+
+describe('sharedCheckMatchNamePattern', () => {
+  it('should pass if all items match the pattern', () => {
+    const items = [{ name: 'UserService' }, { name: 'AuthService' }];
+    const result = sharedCheckMatchNamePattern(
+      items,
+      (i) => i.name,
+      'Item',
+      /Service$/,
+      false,
+    );
+    expect(result.pass).toBe(true);
+  });
+
+  it('should fail if any item does not match the pattern', () => {
+    const items = [{ name: 'UserService' }, { name: 'AuthRepository' }];
+    const result = sharedCheckMatchNamePattern(
+      items,
+      (i) => i.name,
+      'Item',
+      /Service$/,
+      false,
+    );
+    expect(result.pass).toBe(false);
+    expect(result.message()).toContain('AuthRepository does not match pattern');
+  });
+});

package/src/core/shared/sharedCheckMatchNamePattern.ts

@@ -0,0 +1,22 @@
+import { ruleBuilder } from '../utils/ruleBuilder';
+
+export function sharedCheckMatchNamePattern<T>(
+  items: T[],
+  getName: (item: T) => string | undefined,
+  label: string,
+  pattern: string | RegExp,
+  isNot: boolean,
+) {
+  const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+
+  return ruleBuilder(items, isNot, (item) => {
+    const name = getName(item);
+    const passes = name ? regex.test(name) : false;
+    const desc = `${label} ${name || 'Anonymous'}`;
+    return {
+      passes,
+      failMessage: `${desc} does not match pattern ${pattern}, but it should.`,
+      failNotMessage: `${desc} matches pattern ${pattern}, but it shouldn't.`,
+    };
+  });
+}

package/src/core/slices/locateSlices.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { createSourceFile } from '../testUtils';
+import { locateSlices } from './locateSlices';
+
+describe('locateSlices', () => {
+  it('should group files into slices based on pattern', () => {
+    const file1 = createSourceFile('', 'src/domain/auth/index.ts');
+    const file2 = createSourceFile('', 'src/domain/users/index.ts');
+    const file3 = createSourceFile('', 'src/domain/users/user.ts');
+    const result = locateSlices(
+      [file1, file2, file3],
+      // biome-ignore lint/suspicious/noExplicitAny: Mocking TS types for tests
+      {} as any,
+      'src/domain/*',
+    );
+
+    expect(result.sliceIds.size).toBe(2);
+    expect(result.sliceIds.has('auth')).toBe(true);
+    expect(result.sliceIds.has('users')).toBe(true);
+    expect(result.sliceFiles.get('users')?.length).toBe(2);
+  });
+});