@hublo/sentinel 1.4.0-alpha.2 → 1.4.0-alpha.4

package/dist/chunk-MT7VQXRA.js

@@ -0,0 +1,336 @@
+import {
+  decoratorMetadata,
+  tsconfigAliases
+} from "./chunk-3TDUIKVQ.js";
+
+// src/roles/test/shared-test-config.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/roles/test/react/jest-export-conditions.ts
+var ABSENT_UNDER_JEST = /* @__PURE__ */ new Set(["development", "development|production"]);
+function stripInPlace(conditions) {
+  if (conditions === void 0) return;
+  for (let index = conditions.length - 1; index >= 0; index -= 1) {
+    const condition = conditions[index];
+    if (condition !== void 0 && ABSENT_UNDER_JEST.has(condition)) conditions.splice(index, 1);
+  }
+}
+function jestExportConditions() {
+  return {
+    name: "sentinel:jest-export-conditions",
+    configResolved(config) {
+      const environments = config;
+      stripInPlace(config.resolve?.conditions);
+      stripInPlace(config.ssr?.resolve?.conditions);
+      stripInPlace(environments.environments?.ssr?.resolve?.conditions);
+    }
+  };
+}
+
+// src/roles/test/shared-test-config.ts
+function siblingFile(relative) {
+  const candidates = [
+    relative,
+    `roles/test/${relative.replace(/^\.\//, "")}`,
+    `../${relative.replace(/^\.\//, "")}`
+  ];
+  for (const candidate of candidates) {
+    try {
+      const sibling = fileURLToPath(new URL(candidate, import.meta.url));
+      if (existsSync(sibling)) return sibling;
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function resolveFrom(specifier) {
+  try {
+    return fileURLToPath(import.meta.resolve(specifier));
+  } catch {
+    try {
+      return createRequire(import.meta.url).resolve(specifier);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function mockExtendedAdapterPath() {
+  return siblingFile("./setup/mock-extended.js");
+}
+function vitestMockExtendedPath() {
+  try {
+    return fileURLToPath(import.meta.resolve("vitest-mock-extended"));
+  } catch {
+    try {
+      return createRequire(import.meta.url).resolve("vitest-mock-extended");
+    } catch {
+      return "vitest-mock-extended";
+    }
+  }
+}
+function mswAliases() {
+  const server = siblingFile("./setup/msw-server.js");
+  const own = resolveFrom("msw");
+  return [
+    ...own === void 0 ? [] : [{ find: /^msw$/, replacement: own }],
+    ...server === void 0 ? [] : [{ find: /^@hublo\/test\/msw\/server$/, replacement: server }]
+  ];
+}
+function luxonAlias(root, workspaceRoot) {
+  for (const base of [root, workspaceRoot]) {
+    const manifest = join(base, "node_modules", "luxon", "package.json");
+    if (existsSync(manifest)) return [{ find: /^luxon$/, replacement: dirname(manifest) }];
+  }
+  return [];
+}
+function axiosAlias(root, workspaceRoot) {
+  for (const base of [root, workspaceRoot]) {
+    const manifest = join(base, "node_modules", "axios", "package.json");
+    if (existsSync(manifest)) return [{ find: /^axios$/, replacement: dirname(manifest) }];
+  }
+  return [];
+}
+function prismaRuntimeAlias(workspaceRoot) {
+  const prisma = join(workspaceRoot, "node_modules", "@prisma");
+  if (!existsSync(prisma)) return [];
+  return [
+    {
+      find: /^@prisma\/([^/]+)\/runtime\/library$/,
+      replacement: join(prisma, "$1", "runtime", "library.js")
+    }
+  ];
+}
+function baseConfig(options) {
+  const { root, workspaceRoot } = options;
+  return {
+    /*
+     * NO decorator-metadata plugin, and that is a measured removal rather than an omission.
+     *
+     * Nest reads constructor parameter types from `emitDecoratorMetadata`, so this preset used to
+     * run the BUILD role's SWC plugin to emit it, on the premise that the bundler does not. That
+     * premise was true of esbuild and is false of Vite 8, which transforms with oxc: oxc lowers the
+     * decorators itself and emits the metadata, provided a tsconfig with `experimentalDecorators`
+     * applies to the file.
+     *
+     * Measured five times before removing it. On `apps/nest/microservices/mission`, with and
+     * without the plugin, the output is strictly identical for `@Injectable()` constructors
+     * (including a service caught in a two-file import CYCLE, all 8 parameters resolved), for route
+     * handler parameters and return types, and for DTO properties; the suite then passes in 98s
+     * instead of 249s. Confirmed by a direct `Reflect.getMetadata` probe on
+     * `apps/nest/backends-for-frontends/admin` and on `libs/nest/starter`, and by two A/B runs
+     * through this very preset: `agency-notification` (100 tests) identical with and without, and
+     * `grid-leave` (3335 tests) identical without.
+     *
+     * One caveat that the same measurement produced, and which belongs to the CONSUMER rather than
+     * here: a property typed by an interface or by a type-alias imported with `import type` emits
+     * `Object`. That is `emitDecoratorMetadata`'s own behaviour, identical with and without the
+     * plugin, not a Vite regression.
+     *
+     * The BUILD role keeps its plugin. Its context differs, it feeds a shipped artefact, and
+     * removing it there needs its own proof.
+     *
+     * ⚠️ ONE construct escapes oxc, and the exception is why this line is a condition rather than
+     * an empty array: a decorator on an `abstract` class member. swc emitted it, oxc erases the
+     * member and the decorator with it, silently. There is exactly one such member in this repo,
+     * so `lowerDecoratorsWithTypeScript` buys the plugin back for that module alone.
+     */
+    /*
+     * `jestExportConditions` is UNCONDITIONAL, and it is the one plugin every migrated module gets.
+     *
+     * jest resolved with `['node', 'require', 'default']`, read off the installed `@nx/jest/preset`
+     * rather than off its documentation. `development` was never in that list, so a package
+     * shipping a separate development build loaded its PRODUCTION file. Vite's own conditions carry
+     * `development|production`, so `@emotion/cache` loads `emotion-cache.development.cjs.js`, whose
+     * extra stylis plugin calls `console.error(':first-child is potentially unsafe...')`, and with
+     * `jest-fail-on-console` in the setup that console call IS a failure.
+     *
+     * Measured on `libs/front/components`: 2 of its 3 remaining failures, both green again with
+     * this. `apps/front/front-legacy` has 100 over 26 files from the same cause.
+     *
+     * Unconditional rather than reserved for a jsdom module, because it is not a statement about
+     * the DOM: it is what this migration is for, running the suite the way the runner it was
+     * written for ran it. It changes nothing for a module with no dual-published dependency, which
+     * is why nest and cloud were measured identical without it.
+     */
+    plugins: [
+      jestExportConditions(),
+      ...options.lowerDecoratorsWithTypeScript ? [decoratorMetadata({ root })] : []
+    ],
+    /*
+     * The proviso in the paragraph above, made unconditional.
+     *
+     * oxc lowers decorators from the tsconfig that applies to the file, so a file belonging to NO
+     * tsconfig `include` is lowered as if it used the STANDARD decorators, and comes out of Vite as
+     * invalid JavaScript. Not merely without metadata: the file fails to parse, and every file that
+     * imports it disappears with it.
+     *
+     * Measured on `apps/nest/microservices/mission`, where ONE uncovered helper,
+     * `src/app/test/mission.test-wrapper.ts`, took down 158 of 416 test files. Reproduced on a
+     * three-file case: covered file fine, uncovered file `SyntaxError: Invalid or unexpected
+     * token`, and this option alone turns it into the same output the covered file gets, metadata
+     * included.
+     *
+     * Declared here rather than left to each module's tsconfig `include`, because the alternative
+     * is asking 107 teams to find which of their files no tsconfig covers, which is the work this
+     * role exists to do for them.
+     *
+     * Two things the same measurement established, both deliberate:
+     *
+     * - it OVERRIDES the tsconfig, it is not a default the tsconfig refines. A file under a
+     *   tsconfig saying `emitDecoratorMetadata: false` gets metadata anyway. Acceptable because
+     *   this is the NEST preset and a Nest module is legacy decorators by definition: no tsconfig
+     *   under `apps/nest`, `libs/nest`, `apps/cloud` or `libs/cloud` sets either option to false.
+     * - it needs no polyfill. Without `reflect-metadata` loaded, nothing throws, the metadata is
+     *   simply unreadable, exactly as before.
+     */
+    oxc: { decorator: { legacy: true, emitDecoratorMetadata: true } },
+    resolve: {
+      alias: [
+        ...axiosAlias(root, workspaceRoot),
+        ...luxonAlias(root, workspaceRoot),
+        /*
+         * Nest only, and measured: 1186 files under `apps/nest` and `libs/nest` mention `@prisma/`,
+         * and ZERO under `apps/front` and `libs/front`. A React module paying for an alias to a
+         * client it never generates is noise in a file someone has to read.
+         */
+        ...options.flavour === "nest" ? prismaRuntimeAlias(workspaceRoot) : [],
+        ...mswAliases(),
+        /*
+         * `jest-mock-extended` loads `@jest/globals`, which refuses to run outside jest. 2491
+         * files import it, 104 of them under `libs/` as SHARED helpers, so migrating those helpers
+         * breaks every module still on jest and leaving them breaks every module moved to Vitest.
+         * Old and new therefore do not cohabit on shared helpers, which would have killed the
+         * per-module plan.
+         *
+         * This one line removes the constraint: an unmigrated helper resolves to the Vitest fork
+         * inside an adopted module and keeps resolving to the jest one everywhere else.
+         * `vitest-mock-extended@5.1.1` is a fork of the same package and exports the same names.
+         *
+         * Measured on `mission`: failing suites went from 159 to 10.
+         */
+        {
+          find: /^jest-mock-extended$/,
+          replacement: mockExtendedAdapterPath() ?? vitestMockExtendedPath()
+        },
+        ...tsconfigAliases(workspaceRoot)
+      ]
+    },
+    test: {
+      globals: true,
+      environment: "node",
+      root,
+      /*
+       * What the repo's jest preset actually matched, copied rather than approximated:
+       * `**\/?(*.)+(spec|test).[jt]s?(x)`.
+       *
+       * Both NAMES, because jest ran both: `**\/*.spec.ts` alone read green while missing three
+       * `.test.ts` files and 23 tests, with nothing saying so. And all four EXTENSIONS, for the
+       * same reason one notch further out. Measured over the repo's 7063 test files:
+       *
+       *     .ts    5844      .tsx   1108      .js      99      .mjs/.cjs   12
+       *
+       * The `.ts`-only form cost nothing on nest and cloud, which have none of the others, and it
+       * cost `libs/front/api` three files and 13 tests on the first front module it met. Half the
+       * front's test files are `.tsx`.
+       *
+       * `.mjs` and `.cjs` are deliberately OUT: jest's `[jt]s?(x)` does not match them either, and
+       * Vitest's own default include does. Running a file the reference never ran is as wrong as
+       * skipping one it did.
+       */
+      include: ["**/*.spec.[jt]s?(x)", "**/*.test.[jt]s?(x)"],
+      /*
+       * Kept, and it is not a performance knob. Nest registers metadata as an import SIDE EFFECT:
+       * a decorator writes into a catalog when its module loads. Sharing a module registry across
+       * files lets one suite see what another registered, and the failure appears in whichever
+       * file happens to run second.
+       */
+      /*
+       * Nest only. A Nest module registers metadata as an import SIDE EFFECT, so sharing a module
+       * registry across files lets one suite see what another registered. A React module has no
+       * such catalog, and isolation is not free.
+       */
+      ...options.flavour === "nest" ? { isolate: true } : {},
+      /*
+       * Concurrency, transposed from what this repo does today rather than chosen.
+       *
+       * Every jest target inherits `configurations.ci = { ci: true, runInBand: true }` from the
+       * `@nx/jest:jest` key in `nx.json`, and CI invokes every test target with
+       * `--configuration=ci`. So on CI every suite in this repo runs ONE FILE AT A TIME today. That
+       * key belongs to the jest executor and cannot be touched, because the workspace is mixed: it
+       * still serves the modules that have not moved.
+       *
+       * ⚠️ And it is CI-ONLY. A local run omits `--configuration=ci`, so jest runs files in
+       * PARALLEL on a developer's machine. A flat `fileParallelism: false` here would make local
+       * runs slower than jest, which loses something the module had. Hence the condition rather
+       * than the constant: parallel locally, one file at a time on CI, which is jest on both sides.
+       *
+       * Measured on three files that each hold the clock for 400ms and record their interval:
+       *
+       *     default                    files overlap,      402ms
+       *     fileParallelism: false     no overlap,        1442ms
+       *     maxWorkers: 1              no overlap,        1423ms
+       *
+       * Both candidates give the property that matters. `fileParallelism` is the one that says what
+       * the module MEANS ("do not run my files at the same time"); `maxWorkers` is a pool size, and
+       * it is what a module asking for a CAP gets instead (three BFFs ask for 4).
+       *
+       * A module that declared its own concurrency overrides this, in both environments, exactly as
+       * it does today.
+       */
+      fileParallelism: !process.env.CI
+    }
+  };
+}
+function asAliasArray(alias) {
+  if (alias === void 0) return [];
+  if (Array.isArray(alias)) return alias;
+  return Object.entries(alias).map(([find, replacement]) => ({
+    find,
+    replacement
+  }));
+}
+function sharedTestConfig(options) {
+  const base = baseConfig(options);
+  if (options.overrides === void 0) return base;
+  return {
+    ...base,
+    ...options.overrides,
+    plugins: [...base.plugins ?? [], ...options.overrides.plugins ?? []],
+    resolve: {
+      ...base.resolve,
+      ...options.overrides.resolve,
+      /*
+       * The module's own aliases come after sentinel's, and in a Vite alias ARRAY the FIRST match
+       * wins. So sentinel's win, which is the opposite of what this comment used to claim.
+       *
+       * ⚠️ The order is corrected here rather than in the code, because changing it would flip a
+       * behaviour that nothing exercises. Every alias sentinel adds is ANCHORED to one exact
+       * specifier: `^axios$`, `^luxon$`, `^msw$`, `^jest-mock-extended$` and
+       * `^@prisma/<x>/runtime/library$`. A module's own entry collides only by naming the identical
+       * string, and measured across every `jest.config*` in the repo, none does: the closest are
+       * `@front/type/axios` and `@front/api/msw-handlers` in `front-legacy`, different specifiers
+       * in the one module this role refuses anyway.
+       *
+       * So today the order decides nothing, and all 97 migrations were measured with it this way
+       * round. Reversing it on a hypothesis would be a silent behaviour change bought with nothing.
+       * What was actually wrong was a comment promising a module it could win, which a reader would
+       * have relied on.
+       */
+      alias: [
+        ...asAliasArray(base.resolve?.alias),
+        ...asAliasArray(options.overrides.resolve?.alias)
+      ]
+    },
+    test: { ...base.test, ...options.overrides.test }
+  };
+}
+
+export {
+  jestExportConditions,
+  sharedTestConfig
+};
+//# sourceMappingURL=chunk-MT7VQXRA.js.map

package/dist/index.d.ts

@@ -275,6 +275,19 @@ interface Adapter {
      * preview.
      */
     afterInit?(ctx: RunContext): Promise<void>;
+    /**
+     * Run BEFORE `--init` writes anything, so a role can capture what it is about to replace.
+     *
+     * The test role is why this exists. A migration can only be judged against what the module did
+     * BEFORE it, and the jest config is deleted by the very plan that is about to be applied: after
+     * that moment the reference is unobtainable. So the reference is recorded here, at the last
+     * instant it exists.
+     *
+     * Never called under `--dry-run`, which must touch nothing, and a failure here does NOT stop the
+     * init: a module whose jest run is already broken can still be migrated, it simply cannot be
+     * proved, and saying so is better than refusing.
+     */
+    beforeInit?(ctx: RunContext): Promise<void>;
     /**
      * The module's resolved configuration, for `--inspect`: what preset it uses and
      * how it was resolved. Takes the run context so it can report the config as

package/dist/index.js

@@ -7,7 +7,7 @@ import {
   registerAdapters,
   resolve,
   setDefaultRunner
-} from "./chunk-4UIZJ3TR.js";
+} from "./chunk-ASBZQAXV.js";
 import "./chunk-WLFE5RUU.js";
 export {
   BaseAdapter,

package/dist/roles/test/nest/toolchain.d.ts

@@ -1,29 +1,9 @@
 import { ViteUserConfig } from 'vitest/config';
 export { ConfigEnv, TestUserConfig, ViteUserConfig, defineConfig, mergeConfig } from 'vitest/config';
 export { loadEnv } from 'vite';
+import { SharedTestOptions } from '../shared-test-config.js';
 export { A as Alias, D as DecoratorMetadataOptions, d as decoratorMetadata, t as tsconfigAliases } from '../../../tsconfig-aliases-Ce6axdJ4.js';
 
-interface NestTestOptions {
-    /** The module's own directory: where its specs live and what its config is relative to. */
-    root: string;
-    /** The workspace root, which is where `tsconfig.base.json` and its path aliases are. */
-    workspaceRoot: string;
-    /**
-     * Lower decorators with TypeScript before oxc sees them, for a module that needs it.
-     *
-     * ⚠️ Written by `--init --test` from the module's own sources, never by hand, because the
-     * condition is not a preference: it is whether a decorator sits on an `abstract` class member,
-     * the one construct oxc does not reproduce. See `generate-config.ts` for the measurement.
-     *
-     * Off by default, and that default is the measured one: on
-     * `apps/nest/microservices/mission`, 715 of 716 decorated files need nothing, and running the
-     * plugin for all of them took the suite from 98s to 249s.
-     */
-    lowerDecoratorsWithTypeScript?: boolean;
-    /** Merged over the base. For what a module genuinely needs to differ on, nothing else. */
-    overrides?: ViteUserConfig;
-}
-/** The config, with the module's own overrides merged over it. */
-declare function nestTestConfig(options: NestTestOptions): ViteUserConfig;
+declare function nestTestConfig(options: SharedTestOptions): ViteUserConfig;
 
-export { type NestTestOptions, nestTestConfig };
+export { SharedTestOptions as NestTestOptions, nestTestConfig };