@application-kit/testing 0.4.0 → 0.6.0

package/dist/esm/stryker/decide-layer-run.js

@@ -0,0 +1,36 @@
+const isUnder = (file, directory) => file.startsWith(`${directory}/`);
+const isInLayer = (file, layerPaths) => {
+    let isHit = false;
+    for (const entry of layerPaths) {
+        if (entry.startsWith('!')) {
+            if (isUnder(file, entry.slice(1))) {
+                return false;
+            }
+        }
+        else if (isUnder(file, entry)) {
+            isHit = true;
+        }
+    }
+    return isHit;
+};
+const runBecause = (reason) => ({ reason, run: true, touched: [] });
+export const decideLayerRun = (input) => {
+    if (input.changed.length === 0) {
+        return runBecause('дифф пуст');
+    }
+    if (input.changed.some((file) => input.configFiles.test(file))) {
+        return runBecause('тронут конфиг прогона');
+    }
+    const source = input.changed.filter((file) => isUnder(file, input.sourceRoot));
+    if (source.some((file) => input.roots.every((root) => !isUnder(file, root)))) {
+        return runBecause(`тронут ${input.sourceRoot}/ вне групп`);
+    }
+    const shared = input.sharedDirectories.find((directory) => input.changed.some((file) => isUnder(file, directory)));
+    if (shared !== undefined) {
+        return runBecause(`тронута общая тестовая инфраструктура ${shared}`);
+    }
+    const touched = input.changed.filter((file) => isInLayer(file, input.layerPaths));
+    return touched.length === 0
+        ? { reason: 'дифф группу не трогает', run: false, touched }
+        : { reason: 'группа тронута', run: true, touched };
+};

package/dist/esm/stryker/define-stryker-config.d.ts

@@ -0,0 +1,2 @@
+import type { StrykerConfigInterface, StrykerConfigOptionsInterface } from './stryker-config.interface.js';
+export declare const defineStrykerConfig: (options: StrykerConfigOptionsInterface) => StrykerConfigInterface;

package/dist/esm/stryker/define-stryker-config.js

@@ -0,0 +1,20 @@
+import { CODE_WITHOUT_LOGIC } from './code-without-logic.js';
+const DEFAULT_IGNORE_PATTERNS = ['coverage', 'dist', 'node_modules', 'reports'];
+const compare = (left, right) => left.localeCompare(right);
+export const defineStrykerConfig = (options) => ({
+    clearTextReporter: { reportTests: false },
+    dryRunTimeoutMinutes: 10,
+    ignorePatterns: [...DEFAULT_IGNORE_PATTERNS, ...(options.ignorePatterns ?? [])].toSorted(compare),
+    ignoreStatic: true,
+    incremental: true,
+    incrementalFile: options.incrementalFile ?? '.stryker-cache/incremental.json',
+    logLevel: 'warn',
+    mutate: [
+        ...options.mutate.include,
+        ...[...CODE_WITHOUT_LOGIC, ...(options.mutate.exclude ?? [])].map((pattern) => `!${pattern}`),
+    ],
+    tempDirName: options.tempDirName ?? '/tmp/.stryker-tmp',
+    testRunner: 'vitest',
+    thresholds: options.thresholds,
+    vitest: { configFile: options.vitestConfigFile, dir: './' },
+});

package/dist/esm/stryker/define-stryker-layers.d.ts

@@ -0,0 +1,2 @@
+import type { StrykerLayersInterface, StrykerLayersOptionsInterface } from './stryker-layers.interface.js';
+export declare const defineStrykerLayers: (options: StrykerLayersOptionsInterface) => StrykerLayersInterface;

package/dist/esm/stryker/define-stryker-layers.js

@@ -0,0 +1,106 @@
+import { existsSync, readdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+const DEFAULT_LAYER_VARIABLE = 'TYPESCRIPT_MUTATION_LAYER';
+const TEMPLATE_LAYER_SENTINEL = 'all';
+const MATRIX_PATTERN = (variable) => {
+    const source = [variable, ':\\p{White_Space}*\\[([^\\]]*)\\]'].join('');
+    return new RegExp(source, 'u');
+};
+const sorted = (values) => [...values].toSorted((left, right) => left.localeCompare(right));
+const isUnderDirectory = (file, directory) => file.startsWith(`${directory}/`);
+const rootsOf = (options) => [
+    ...options.scope.directories,
+    ...options.scope.parents.flatMap((parent) => readdirSync(path.join(options.root, parent), { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => `${parent}/${entry.name}`)),
+];
+const assertLayout = (layers, roots, configName) => {
+    const paths = Object.values(layers).flatMap((layer) => layer.paths);
+    const unassigned = roots.filter((root) => !paths.includes(root));
+    const duplicated = paths.filter((entry, index) => paths.indexOf(entry) !== index);
+    const orphaned = paths.filter((entry) => roots.every((root) => !(entry === root || isUnderDirectory(entry, root))));
+    if (unassigned.length > 0 || duplicated.length > 0 || orphaned.length > 0) {
+        throw new Error(`${configName}: каталог обязан быть ровно в одной группе — без группы: [${unassigned.join(', ')}], `
+            + `в двух: [${duplicated.join(', ')}], вне корней: [${orphaned.join(', ')}]`);
+    }
+};
+const assertMatrix = (options, variable, configName) => {
+    const matrix = MATRIX_PATTERN(variable).exec(readFileSync(options.ciFile).toString());
+    const matrixLayers = sorted((matrix?.[1] ?? '').split(',').map((name) => name.trim())
+        .filter(Boolean));
+    const layerNames = sorted(Object.keys(options.layers));
+    if (matrixLayers.join(',') !== layerNames.join(',')) {
+        throw new Error(`${configName}: матрица [${matrixLayers.join(', ')}] в ${path.basename(options.ciFile)} `
+            + `расходится с группами [${layerNames.join(', ')}]`);
+    }
+};
+const carvedOutOf = (allPaths, layer) => {
+    const isCarvedOut = (entry) => {
+        const isOwn = layer.paths.includes(entry);
+        return !isOwn && layer.paths.some((own) => isUnderDirectory(entry, own));
+    };
+    return allPaths.filter((entry) => isCarvedOut(entry));
+};
+const pruneIncrementalReport = (incrementalFile, isInScope, configName) => {
+    if (!existsSync(incrementalFile)) {
+        return;
+    }
+    const report = JSON.parse(readFileSync(incrementalFile, 'utf8'));
+    const files = report.files ?? {};
+    const foreign = Object.keys(files).filter((file) => !isInScope(file));
+    if (foreign.length === 0) {
+        return;
+    }
+    report.files = Object.fromEntries(Object.entries(files).filter(([file]) => isInScope(file)));
+    writeFileSync(`${incrementalFile}.tmp`, JSON.stringify(report));
+    renameSync(`${incrementalFile}.tmp`, incrementalFile);
+    console.error(`${configName}: из ${incrementalFile} убрано файлов вне области группы: ${foreign.length}`);
+};
+export const defineStrykerLayers = (options) => {
+    const variable = options.layerVariable ?? DEFAULT_LAYER_VARIABLE;
+    const configName = options.configName ?? 'stryker layers';
+    const names = Object.keys(options.layers);
+    const allPaths = Object.values(options.layers).flatMap((layer) => layer.paths);
+    const roots = rootsOf(options);
+    assertLayout(options.layers, roots, configName);
+    assertMatrix(options, variable, configName);
+    const layerOf = (name) => {
+        const layer = options.layers[String(name)];
+        if (layer === undefined) {
+            throw new Error(`${variable}=${String(name)}: ожидается одна из ${names.join(', ')}`);
+        }
+        return { layer, name: String(name) };
+    };
+    const pathsOf = (name) => {
+        const { layer } = layerOf(name);
+        return [...layer.paths, ...carvedOutOf(allPaths, layer).map((entry) => `!${entry}`)];
+    };
+    const raw = process.env[variable];
+    const isLoadedByStryker = process.argv.some((argument) => argument.includes('@stryker-mutator'));
+    const isUnset = raw === undefined || (!isLoadedByStryker && raw === TEMPLATE_LAYER_SENTINEL);
+    const { layer, name } = layerOf(isUnset ? options.defaultLayer : raw);
+    const carvedOut = carvedOutOf(allPaths, layer);
+    const incrementalFile = `.stryker-cache/incremental-${name}.json`;
+    if (isLoadedByStryker) {
+        pruneIncrementalReport(path.join(options.root, incrementalFile), (file) => layer.paths.some((own) => isUnderDirectory(file, own))
+            && carvedOut.every((entry) => !isUnderDirectory(file, entry)), configName);
+    }
+    const exclusions = options.base.mutate.filter((pattern) => pattern.startsWith('!'));
+    return {
+        config: {
+            ...options.base,
+            incrementalFile,
+            mutate: [
+                ...layer.paths.map((entry) => `${entry}/**/*.ts`),
+                ...carvedOut.map((entry) => `!${entry}/**`),
+                ...exclusions,
+            ],
+            thresholds: { ...options.base.thresholds, break: layer.break },
+        },
+        names,
+        paths: pathsOf,
+        roots,
+        skip: options.skip,
+    };
+};

package/dist/esm/stryker/index.d.ts

@@ -0,0 +1,7 @@
+export * from './code-without-logic.js';
+export * from './decide-layer-run.js';
+export * from './define-stryker-config.js';
+export * from './define-stryker-layers.js';
+export * from './mutation-layer-cli.js';
+export * from './stryker-config.interface.js';
+export * from './stryker-layers.interface.js';

package/dist/esm/stryker/index.js

@@ -0,0 +1,7 @@
+export * from './code-without-logic.js';
+export * from './decide-layer-run.js';
+export * from './define-stryker-config.js';
+export * from './define-stryker-layers.js';
+export * from './mutation-layer-cli.js';
+export * from './stryker-config.interface.js';
+export * from './stryker-layers.interface.js';

package/dist/esm/stryker/mutation-layer-cli.d.ts

@@ -0,0 +1,9 @@
+import type { StrykerLayersInterface } from './stryker-layers.interface.js';
+export interface MutationLayerCliDependenciesInterface {
+    changedFiles(base: string): string[];
+    env: Readonly<Record<string, string | undefined>>;
+    loadLayers(config: string): Promise<StrykerLayersInterface>;
+    print(line: string): void;
+    run(command: string): number;
+}
+export declare const executeMutationLayerCli: (argv: readonly string[], dependencies: MutationLayerCliDependenciesInterface) => Promise<number>;

package/dist/esm/stryker/mutation-layer-cli.js

@@ -0,0 +1,60 @@
+import { decideLayerRun } from './decide-layer-run.js';
+const DEFAULT_CONFIG = 'stryker.layer.conf.mjs';
+const DEFAULT_LAYER_VARIABLE = 'TYPESCRIPT_MUTATION_LAYER';
+const defaultCommand = (config) => `yarn stryker run ${config} --logLevel info --concurrency 2`;
+const parse = (argv) => {
+    const positional = argv.filter((argument) => !argument.startsWith('--'));
+    const flag = argv.find((argument) => argument.startsWith('--config='));
+    return { base: positional[1], command: positional[0], config: flag?.slice('--config='.length) ?? DEFAULT_CONFIG };
+};
+const NO_BASE_REASON = 'базы диффа нет (не MR-пайплайн)';
+const changedFilesOf = (dependencies, base) => {
+    try {
+        return dependencies.changedFiles(base);
+    }
+    catch (error) {
+        return Error.isError(error) ? error : new Error(String(error));
+    }
+};
+const labelOf = (cell) => `ts:test:mutation [${String(cell.layer)}]`;
+const launch = (cell, reason) => {
+    cell.dependencies.print(`${labelOf(cell)}: прогон — ${reason}`);
+    return cell.dependencies.run(cell.dependencies.env.MUTATION_LAYER_COMMAND ?? defaultCommand(cell.config));
+};
+const runCell = (cell) => {
+    const { dependencies, layer, layers } = cell;
+    const diffBase = cell.base ?? dependencies.env.CI_MERGE_REQUEST_DIFF_BASE_SHA;
+    if (diffBase === undefined || diffBase === '') {
+        return launch(cell, NO_BASE_REASON);
+    }
+    const changed = changedFilesOf(dependencies, diffBase);
+    if (Error.isError(changed)) {
+        return launch(cell, `дифф к ${diffBase} не читается: ${changed.message.replace(/\n[\s\S]*/u, '')}`);
+    }
+    const decision = decideLayerRun({ ...layers.skip, changed, layerPaths: layers.paths(layer), roots: layers.roots });
+    if (!decision.run) {
+        dependencies.print(`${labelOf(cell)}: дифф MR (база ${diffBase}) группу не трогает — прогон пропущен, кеш и score группы без изменений`);
+        return 0;
+    }
+    if (decision.touched.length > 0) {
+        dependencies.print(`${labelOf(cell)}: дифф MR трогает группу:\n${decision.touched.map((file) => `  ${file}`).join('\n')}`);
+    }
+    return launch(cell, decision.reason);
+};
+export const executeMutationLayerCli = async (argv, dependencies) => {
+    const { base, command, config } = parse(argv);
+    const layers = await dependencies.loadLayers(config);
+    if (command === 'names') {
+        dependencies.print(layers.names.join(' '));
+        return 0;
+    }
+    if (command === 'paths') {
+        dependencies.print(layers.paths(dependencies.env[DEFAULT_LAYER_VARIABLE]).join('\n'));
+        return 0;
+    }
+    if (command === 'run') {
+        return runCell({ base, config, dependencies, layer: dependencies.env[DEFAULT_LAYER_VARIABLE], layers });
+    }
+    dependencies.print(`application-mutation-layer: ожидается names | paths | run, получено ${String(command)}`);
+    return 2;
+};

package/dist/esm/stryker/stryker-config.interface.d.ts

@@ -0,0 +1,23 @@
+export interface StrykerConfigInterface {
+    readonly incrementalFile: string;
+    readonly mutate: readonly string[];
+    readonly [option: string]: unknown;
+    readonly thresholds: StrykerThresholdsInterface;
+}
+export interface StrykerConfigOptionsInterface {
+    ignorePatterns?: readonly string[];
+    incrementalFile?: string;
+    mutate: StrykerMutateScopeInterface;
+    tempDirName?: string;
+    thresholds: StrykerThresholdsInterface;
+    vitestConfigFile: string;
+}
+export interface StrykerMutateScopeInterface {
+    exclude?: readonly string[];
+    include: readonly string[];
+}
+export interface StrykerThresholdsInterface {
+    readonly break: number;
+    readonly high: number;
+    readonly low: number;
+}

package/dist/esm/stryker/stryker-config.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/stryker/stryker-layers.interface.d.ts

@@ -0,0 +1,31 @@
+import type { StrykerConfigInterface } from './stryker-config.interface.js';
+export interface StrykerLayerInterface {
+    break: number;
+    paths: readonly string[];
+}
+export interface StrykerLayersInterface {
+    config: StrykerConfigInterface;
+    names: readonly string[];
+    paths(name: string | undefined): string[];
+    roots: readonly string[];
+    skip: StrykerLayerSkipOptionsInterface;
+}
+export interface StrykerLayerSkipOptionsInterface {
+    configFiles: RegExp;
+    sharedDirectories: readonly string[];
+    sourceRoot: string;
+}
+export interface StrykerLayersOptionsInterface {
+    base: StrykerConfigInterface;
+    ciFile: string;
+    configName?: string;
+    defaultLayer: string;
+    layers: Readonly<Record<string, StrykerLayerInterface>>;
+    layerVariable?: string;
+    root: string;
+    scope: {
+        directories: readonly string[];
+        parents: readonly string[];
+    };
+    skip: StrykerLayerSkipOptionsInterface;
+}

package/dist/esm/stryker/stryker-layers.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/vitest/setup/fast-bcrypt-cost.d.ts

@@ -0,0 +1,5 @@
+export interface BcryptInterface {
+    compare(data: Buffer | string, encrypted: string): Promise<boolean>;
+    hash(data: Buffer | string, saltOrRounds: number | string): Promise<string>;
+}
+export declare const withFastBcryptCost: (bcrypt: BcryptInterface) => BcryptInterface;

package/dist/esm/vitest/setup/fast-bcrypt-cost.js

@@ -0,0 +1,13 @@
+const FAST_ROUNDS = 4;
+const COST_FIELD_WIDTH = 2;
+const COST_FIELD = /^(?<prefix>\$2[aby]\$)\d{2}\$/u;
+const withCost = (hashed, rounds) => {
+    const cost = String(rounds).padStart(COST_FIELD_WIDTH, '0');
+    return hashed.replace(COST_FIELD, (_match, prefix) => `${prefix}${cost}$`);
+};
+export const withFastBcryptCost = (bcrypt) => ({
+    compare: async (data, encrypted) => bcrypt.compare(data, withCost(encrypted, FAST_ROUNDS)),
+    hash: async (data, saltOrRounds) => (typeof saltOrRounds === 'number'
+        ? withCost(await bcrypt.hash(data, Math.min(saltOrRounds, FAST_ROUNDS)), saltOrRounds)
+        : bcrypt.hash(data, saltOrRounds)),
+});

package/dist/esm/vitest/setup/fast-bcrypt.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/vitest/setup/fast-bcrypt.js

@@ -0,0 +1,7 @@
+import { vi } from 'vitest';
+import { withFastBcryptCost } from './fast-bcrypt-cost.js';
+vi.mock('bcrypt', async (importOriginal) => {
+    const bcrypt = await importOriginal();
+    const fast = withFastBcryptCost(bcrypt);
+    return { ...bcrypt, ...fast, default: { ...bcrypt.default, ...fast } };
+});

package/dist/esm/vitest/setup/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fast-bcrypt.js';
+export * from './fast-bcrypt-cost.js';

package/dist/esm/vitest/setup/index.js

@@ -0,0 +1,2 @@
+export * from './fast-bcrypt.js';
+export * from './fast-bcrypt-cost.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@application-kit/testing",
-  "version": "0.4.0",
-  "description": "Тестовая инфраструктура NestJS-приложений: шины CQRS, логгер, фейковый microservice, сборка web-приложения, Postgres в testcontainers, раскладка ячеек CI по проектам vitest и фабрики конфигов vitest",
+  "version": "0.6.0",
+  "description": "Тестовая инфраструктура NestJS-приложений: шины CQRS, логгер, фейковый microservice, сборка web-приложения, Postgres в testcontainers, запуск e2e-приложения, изоляция окружения прогона, дешёвый bcrypt для unit-прогона, раскладка ячеек CI по проектам vitest и фабрики конфигов vitest",
   "keywords": [
     "cqrs",
     "nestjs",
@@ -34,6 +34,16 @@
       }
     },
     "./package.json": "./package.json",
+    "./stryker": {
+      "import": {
+        "types": "./dist/esm/stryker/index.d.ts",
+        "default": "./dist/esm/stryker/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/stryker/index.d.ts",
+        "default": "./dist/cjs/stryker/index.js"
+      }
+    },
     "./vitest": {
       "import": {
         "types": "./dist/esm/vitest/index.d.ts",
@@ -43,22 +53,35 @@
         "types": "./dist/cjs/vitest/index.d.ts",
         "default": "./dist/cjs/vitest/index.js"
       }
+    },
+    "./vitest/fast-bcrypt": {
+      "import": {
+        "types": "./dist/esm/vitest/setup/fast-bcrypt.d.ts",
+        "default": "./dist/esm/vitest/setup/fast-bcrypt.js"
+      },
+      "require": {
+        "types": "./dist/cjs/vitest/setup/fast-bcrypt.d.ts",
+        "default": "./dist/cjs/vitest/setup/fast-bcrypt.js"
+      }
     }
   },
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/cjs/index.d.ts",
+  "bin": {
+    "application-mutation-layer": "./dist/esm/stryker/bin/application-mutation-layer.js"
+  },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf ./dist && node ../../scripts/barrels.mjs create ./src --entry-only=vitest && tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && node ../../scripts/barrels.mjs clean ./src && node ../../scripts/mark-cjs.mjs ./dist/cjs",
+    "build": "rm -rf ./dist && node ../../scripts/barrels.mjs create ./src --entry-only=bin,setup,stryker,vitest && tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && node ../../scripts/barrels.mjs clean ./src && node ../../scripts/mark-cjs.mjs ./dist/cjs",
     "lint:tsc": "tsc --noEmit --pretty --project .",
     "test:mutation": "stryker run",
     "test:unit": "vitest run"
   },
   "dependencies": {
-    "@application-kit/bootstrap": "^0.2.0"
+    "@application-kit/bootstrap": "^0.2.2"
   },
   "devDependencies": {
     "@nestjs/common": "^11.2.7",
@@ -70,6 +93,7 @@
     "@stryker-mutator/core": "^10.0.0",
     "@stryker-mutator/vitest-runner": "^10.0.0",
     "@types/node": "^26.2.0",
+    "bcrypt": "^6.0.0",
     "nestjs-pino": "^4.6.1",
     "oxide.ts": "^1.1.0",
     "pino": "^10.3.1",
@@ -89,6 +113,7 @@
     "@nestjs/microservices": "^11.0.0",
     "@nestjs/platform-fastify": "^11.0.0",
     "@nestjs/testing": "^11.0.0",
+    "bcrypt": "^6.0.0",
     "nestjs-pino": "^4.6.1",
     "oxide.ts": "^1.1.0",
     "rxjs": "^7.8.2",
@@ -98,6 +123,9 @@
     "vitest": "^4.1.0"
   },
   "peerDependenciesMeta": {
+    "bcrypt": {
+      "optional": true
+    },
     "vite": {
       "optional": true
     },