@vitronai/themis 0.1.0-beta.0 → 0.1.0-beta.2

package/src/migrate.js

@@ -0,0 +1,280 @@
+const fs = require('fs');
+const path = require('path');
+const { DEFAULT_CONFIG, loadConfig } = require('./config');
+
+const SUPPORTED_MIGRATION_SOURCES = new Set(['jest', 'vitest']);
+const THEMIS_SETUP_FILE = path.join('tests', 'setup.themis.js');
+const THEMIS_COMPAT_FILE = 'themis.compat.js';
+const MIGRATION_REPORT_FILE = path.join('.themis', 'migration-report.json');
+const SCANNABLE_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+const IGNORED_DIRECTORIES = new Set(['node_modules', '.git', '.themis']);
+
+function runMigrate(cwd, framework, options = {}) {
+  const source = String(framework || '').trim().toLowerCase();
+  if (!SUPPORTED_MIGRATION_SOURCES.has(source)) {
+    throw new Error(`Unsupported migrate source: ${String(framework)}. Use "jest" or "vitest".`);
+  }
+
+  const projectRoot = path.resolve(cwd || process.cwd());
+  const configPath = path.join(projectRoot, 'themis.config.json');
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  const setupPath = path.join(projectRoot, THEMIS_SETUP_FILE);
+  const compatPath = path.join(projectRoot, THEMIS_COMPAT_FILE);
+  const reportPath = path.join(projectRoot, MIGRATION_REPORT_FILE);
+
+  const existingConfig = fs.existsSync(configPath) ? loadConfig(projectRoot) : { ...DEFAULT_CONFIG, setupFiles: [], testIgnore: [] };
+  const nextSetupFiles = Array.isArray(existingConfig.setupFiles) ? [...existingConfig.setupFiles] : [];
+  if (!nextSetupFiles.includes(THEMIS_SETUP_FILE)) {
+    nextSetupFiles.push(THEMIS_SETUP_FILE);
+  }
+
+  const nextConfig = {
+    ...existingConfig,
+    setupFiles: nextSetupFiles
+  };
+
+  fs.mkdirSync(path.dirname(setupPath), { recursive: true });
+  if (!fs.existsSync(setupPath)) {
+    fs.writeFileSync(setupPath, buildMigrationSetupSource(source), 'utf8');
+  }
+
+  if (!fs.existsSync(compatPath)) {
+    fs.writeFileSync(compatPath, buildMigrationCompatSource(), 'utf8');
+  }
+
+  fs.writeFileSync(configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, 'utf8');
+
+  let packageUpdated = false;
+  if (fs.existsSync(packageJsonPath)) {
+    const parsed = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const scripts = parsed.scripts && typeof parsed.scripts === 'object' ? { ...parsed.scripts } : {};
+    if (!scripts['test:themis']) {
+      scripts['test:themis'] = 'themis test';
+      parsed.scripts = scripts;
+      fs.writeFileSync(packageJsonPath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8');
+      packageUpdated = true;
+    }
+  }
+
+  const scan = scanMigrationFiles(projectRoot);
+  const rewriteSummary = options.rewriteImports
+    ? rewriteMigrationImports(projectRoot, scan.matches, compatPath)
+    : { rewrittenFiles: [], rewrittenImports: 0 };
+  const report = buildMigrationReport(projectRoot, source, scan.matches, rewriteSummary);
+  fs.mkdirSync(path.dirname(reportPath), { recursive: true });
+  fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+
+  return {
+    source,
+    configPath,
+    setupPath,
+    compatPath,
+    packageJsonPath: fs.existsSync(packageJsonPath) ? packageJsonPath : null,
+    packageUpdated,
+    reportPath,
+    report,
+    rewriteImports: Boolean(options.rewriteImports),
+    rewrittenFiles: rewriteSummary.rewrittenFiles
+  };
+}
+
+function buildMigrationSetupSource(source) {
+  return `// Themis migration bridge for ${source} suites.
+// Themis runtime supports imports from "@jest/globals", "vitest",
+// and "@testing-library/react" directly, so this file can stay minimal.
+
+afterEach(() => {
+  restoreAllMocks();
+  cleanup();
+});
+`;
+}
+
+function buildMigrationCompatSource() {
+  return `const themisCompat = {
+  describe,
+  test,
+  it: test,
+  expect,
+  beforeAll,
+  beforeEach,
+  afterEach,
+  afterAll,
+  render,
+  screen,
+  fireEvent,
+  waitFor,
+  cleanup,
+  act: async (callback) => (typeof callback === 'function' ? callback() : undefined)
+};
+
+const jestLike = {
+  fn,
+  spyOn,
+  mock,
+  unmock,
+  clearAllMocks,
+  resetAllMocks,
+  restoreAllMocks,
+  useFakeTimers,
+  useRealTimers,
+  advanceTimersByTime,
+  runAllTimers
+};
+
+module.exports = {
+  ...themisCompat,
+  jest: jestLike,
+  vi: jestLike
+};
+`;
+}
+
+function scanMigrationFiles(projectRoot) {
+  const files = [];
+  walkProject(projectRoot, files);
+  const matches = [];
+
+  for (const file of files) {
+    const sourceText = fs.readFileSync(file, 'utf8');
+    const relativeFile = path.relative(projectRoot, file).split(path.sep).join('/');
+    const detected = detectMigrationImports(sourceText);
+    if (detected.length === 0) {
+      continue;
+    }
+
+    matches.push({
+      file: relativeFile,
+      imports: detected
+    });
+  }
+
+  return {
+    files,
+    matches
+  };
+}
+
+function buildMigrationReport(projectRoot, source, matches, rewriteSummary = { rewrittenFiles: [], rewrittenImports: 0 }) {
+  return {
+    schema: 'themis.migration.report.v1',
+    source,
+    createdAt: new Date().toISOString(),
+    summary: {
+      matchedFiles: matches.length,
+      jestGlobals: matches.filter((entry) => entry.imports.includes('@jest/globals')).length,
+      vitest: matches.filter((entry) => entry.imports.includes('vitest')).length,
+      testingLibraryReact: matches.filter((entry) => entry.imports.includes('@testing-library/react')).length,
+      rewrittenFiles: Array.isArray(rewriteSummary.rewrittenFiles) ? rewriteSummary.rewrittenFiles.length : 0,
+      rewrittenImports: Number(rewriteSummary.rewrittenImports || 0)
+    },
+    files: matches,
+    nextActions: [
+      'Run npx themis test to execute migrated suites under the Themis runtime.',
+      'Replace any unsupported Jest/Vitest-only helpers with Themis built-ins or project setup utilities.',
+      'Use npx themis generate src for source-driven unit-layer coverage alongside migrated suites.'
+    ],
+    rewrites: Array.isArray(rewriteSummary.rewrittenFiles)
+      ? rewriteSummary.rewrittenFiles
+      : []
+  };
+}
+
+function rewriteMigrationImports(projectRoot, matches, compatPath) {
+  const rewrittenFiles = [];
+  let rewrittenImports = 0;
+
+  for (const match of matches) {
+    const absoluteFile = path.join(projectRoot, match.file);
+    const original = fs.readFileSync(absoluteFile, 'utf8');
+    const compatSpecifier = toPortableRelativeSpecifier(path.relative(path.dirname(absoluteFile), compatPath));
+    const rewritten = rewriteMigrationSourceText(original, compatSpecifier);
+    if (rewritten.source !== original) {
+      fs.writeFileSync(absoluteFile, rewritten.source, 'utf8');
+      rewrittenFiles.push(match.file);
+      rewrittenImports += rewritten.rewrites;
+    }
+  }
+
+  return {
+    rewrittenFiles,
+    rewrittenImports
+  };
+}
+
+function rewriteMigrationSourceText(sourceText, compatSpecifier) {
+  const patterns = [
+    /(['"])@jest\/globals\1/g,
+    /(['"])vitest\1/g,
+    /(['"])@testing-library\/react\1/g
+  ];
+
+  let rewrites = 0;
+  let nextSource = sourceText;
+  for (const pattern of patterns) {
+    nextSource = nextSource.replace(pattern, (match, quote) => {
+      rewrites += 1;
+      return `${quote}${compatSpecifier}${quote}`;
+    });
+  }
+
+  return {
+    source: nextSource,
+    rewrites
+  };
+}
+
+function walkProject(dir, files) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (IGNORED_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+      walkProject(path.join(dir, entry.name), files);
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    const extension = path.extname(entry.name).toLowerCase();
+    if (!SCANNABLE_EXTENSIONS.has(extension)) {
+      continue;
+    }
+
+    files.push(path.join(dir, entry.name));
+  }
+}
+
+function detectMigrationImports(sourceText) {
+  const matches = [];
+  if (hasModuleReference(sourceText, '@jest/globals')) {
+    matches.push('@jest/globals');
+  }
+  if (hasModuleReference(sourceText, 'vitest')) {
+    matches.push('vitest');
+  }
+  if (hasModuleReference(sourceText, '@testing-library/react')) {
+    matches.push('@testing-library/react');
+  }
+  return matches;
+}
+
+function hasModuleReference(sourceText, moduleName) {
+  const escaped = moduleName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(?:import\\s+[^;]*?from\\s+['"]${escaped}['"]|import\\s*\\(\\s*['"]${escaped}['"]\\s*\\)|require\\(\\s*['"]${escaped}['"]\\s*\\))`).test(sourceText);
+}
+
+function toPortableRelativeSpecifier(relativePath) {
+  const normalized = String(relativePath || '').split(path.sep).join('/');
+  if (normalized.startsWith('.')) {
+    return normalized;
+  }
+  return `./${normalized}`;
+}
+
+module.exports = {
+  runMigrate
+};

package/src/module-loader.js

@@ -13,6 +13,9 @@ const DEFAULT_TS_COMPILER_OPTIONS = {
 
 function createModuleLoader(options = {}) {
   const projectRoot = safeRealpath(path.resolve(options.cwd || process.cwd()));
+  const virtualModules = options.virtualModules && typeof options.virtualModules === 'object'
+    ? options.virtualModules
+    : {};
   const tsconfigPath = options.tsconfigPath === null
     ? null
     : resolveTsconfigPath(projectRoot, options.tsconfigPath);
@@ -53,6 +56,10 @@ function createModuleLoader(options = {}) {
   }
 
   Module._resolveFilename = function themisResolveFilename(request, parent, isMain, resolutionOptions) {
+    if (Object.prototype.hasOwnProperty.call(virtualModules, request)) {
+      return request;
+    }
+
     const aliasedRequest = resolveConfiguredRequest({
       request,
       parentFile: parent && parent.filename,
@@ -70,13 +77,19 @@ function createModuleLoader(options = {}) {
   };
 
   Module._load = function themisModuleLoad(request, parent, isMain) {
+    if (Object.prototype.hasOwnProperty.call(virtualModules, request)) {
+      const virtualValue = virtualModules[request];
+      return typeof virtualValue === 'function' ? virtualValue() : virtualValue;
+    }
+
     const resolvedRequest = resolveRequestValue({
       request,
       parentFile: parent && parent.filename,
       projectRoot,
       compilerContext,
       originalResolveFilename,
-      isMain
+      isMain,
+      virtualModules
     });
 
     if (mockRegistry.has(resolvedRequest)) {
@@ -116,7 +129,8 @@ function createModuleLoader(options = {}) {
         parentFile,
         projectRoot,
         compilerContext,
-        originalResolveFilename
+        originalResolveFilename,
+        virtualModules
       });
     },
     registerMock(request, parentFile, factoryOrExports) {
@@ -158,8 +172,13 @@ function resolveRequestValue({
   projectRoot,
   compilerContext,
   originalResolveFilename,
-  isMain = false
+  isMain = false,
+  virtualModules = null
 }) {
+  if (virtualModules && Object.prototype.hasOwnProperty.call(virtualModules, request)) {
+    return request;
+  }
+
   const normalizedParent = parentFile ? safeRealpath(path.resolve(parentFile)) : path.join(projectRoot, '__themis_entry__.js');
   const parentModule = {
     id: normalizedParent,

package/src/reporter.js

@@ -66,7 +66,8 @@ function printAgent(result) {
     lastRun: '.themis/last-run.json',
     failedTests: '.themis/failed-tests.json',
     runDiff: '.themis/run-diff.json',
-    runHistory: '.themis/run-history.json'
+    runHistory: '.themis/run-history.json',
+    fixHandoff: '.themis/fix-handoff.json'
   };
 
   const payload = {
@@ -84,8 +85,8 @@ function printAgent(result) {
     hints: {
       rerunFailed: 'npx themis test --rerun-failed',
       targetedRerun: 'npx themis test --match "<regex>"',
-      updateSnapshots: 'npx themis test -u',
-      diffLastRun: 'cat .themis/run-diff.json'
+      diffLastRun: 'cat .themis/run-diff.json',
+      repairGenerated: 'cat .themis/fix-handoff.json'
     }
   };
 

package/src/runner.js

@@ -1,20 +1,19 @@
+const fs = require('fs');
 const path = require('path');
 const { Worker } = require('worker_threads');
 const { performance } = require('perf_hooks');
+const { collectAndRun } = require('./runtime');
+
+const inProcessResultCache = new Map();
 
 async function runTests(files, options = {}) {
   const startedAt = performance.now();
   const startedAtIso = new Date().toISOString();
-  const maxWorkers = resolveMaxWorkers(options.maxWorkers);
-  const queue = [...files];
-  const workers = [];
-  const fileResults = [];
-
-  for (let i = 0; i < Math.min(maxWorkers, files.length); i += 1) {
-    workers.push(runNext(queue, fileResults, options));
-  }
-
-  await Promise.all(workers);
+  const isolation = resolveIsolationMode(options);
+  const maxWorkers = isolation === 'in-process' ? 1 : resolveMaxWorkers(options.maxWorkers);
+  const fileResults = isolation === 'in-process'
+    ? await runFilesInProcess(files, options)
+    : await runFilesInWorkers(files, options);
 
   fileResults.sort((a, b) => a.file.localeCompare(b.file));
 
@@ -41,6 +40,27 @@ async function runTests(files, options = {}) {
   };
 }
 
+async function runFilesInWorkers(files, options) {
+  const queue = [...files];
+  const workers = [];
+  const fileResults = [];
+
+  for (let i = 0; i < Math.min(resolveMaxWorkers(options.maxWorkers), files.length); i += 1) {
+    workers.push(runNext(queue, fileResults, options));
+  }
+
+  await Promise.all(workers);
+  return fileResults;
+}
+
+async function runFilesInProcess(files, options) {
+  const fileResults = [];
+  for (const file of files) {
+    fileResults.push(await runFileInProcess(file, options));
+  }
+  return fileResults;
+}
+
 async function runNext(queue, fileResults, options) {
   while (queue.length > 0) {
     const file = queue.shift();
@@ -63,8 +83,7 @@ function runFileInWorker(file, options = {}) {
         cwd: options.cwd || process.cwd(),
         environment: options.environment || 'node',
         setupFiles: Array.isArray(options.setupFiles) ? options.setupFiles : [],
-        tsconfigPath: options.tsconfigPath === undefined ? undefined : options.tsconfigPath,
-        updateSnapshots: Boolean(options.updateSnapshots)
+        tsconfigPath: options.tsconfigPath === undefined ? undefined : options.tsconfigPath
       }
     });
 
@@ -155,6 +174,47 @@ function runFileInWorker(file, options = {}) {
   });
 }
 
+async function runFileInProcess(file, options = {}) {
+  const cacheKey = options.cache ? buildInProcessCacheKey(file, options) : null;
+  if (cacheKey && inProcessResultCache.has(cacheKey)) {
+    return cloneResult(inProcessResultCache.get(cacheKey));
+  }
+
+  const result = await collectAndRun(file, options);
+  if (cacheKey) {
+    inProcessResultCache.set(cacheKey, cloneResult(result));
+  }
+  return result;
+}
+
+function buildInProcessCacheKey(file, options) {
+  const stats = fs.statSync(file);
+  return JSON.stringify({
+    file: path.resolve(file),
+    size: stats.size,
+    mtimeMs: Math.round(stats.mtimeMs),
+    match: options.match || null,
+    allowedFullNames: Array.isArray(options.allowedFullNames) ? options.allowedFullNames : null,
+    noMemes: Boolean(options.noMemes),
+    cwd: options.cwd || process.cwd(),
+    environment: options.environment || 'node',
+    setupFiles: Array.isArray(options.setupFiles) ? options.setupFiles : [],
+    tsconfigPath: options.tsconfigPath === undefined ? '__default__' : options.tsconfigPath
+  });
+}
+
+function cloneResult(result) {
+  return JSON.parse(JSON.stringify(result));
+}
+
+function clearRunCache() {
+  inProcessResultCache.clear();
+}
+
+function resolveIsolationMode(options = {}) {
+  return options.isolation === 'in-process' ? 'in-process' : 'worker';
+}
+
 function resolveMaxWorkers(value) {
   const parsed = Number(value);
   if (!Number.isFinite(parsed) || parsed < 1) {
@@ -164,5 +224,6 @@ function resolveMaxWorkers(value) {
 }
 
 module.exports = {
-  runTests
+  runTests,
+  clearRunCache
 };