@archest/vitest 1.0.1 → 1.0.2

package/src/core/layers/createLayeredArchitecture.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/core/project/parseProject.ts

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

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

@@ -1,41 +0,0 @@
-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,
-  };
-}