@hublo/sentinel 1.4.0-alpha.14 → 1.4.0-alpha.16

package/dist/bin/sentinel.js

@@ -16,7 +16,7 @@ import {
   registerAdapters,
   resolve,
   resolveBin
-} from "../chunk-YHGCBMKJ.js";
+} from "../chunk-XGC2KK5J.js";
 import {
   WORKSPACE_ROOT_MARKER,
   ensureWorkspacePrep,

package/dist/{chunk-YHGCBMKJ.js → chunk-XGC2KK5J.js}

@@ -6990,6 +6990,78 @@ function rewriteMockFactoryDefault(source, program, defaultImported) {
   };
 }
 
+// src/roles/test/codemod/mock-promise-resolve.ts
+var MOCK_FACTORY = /* @__PURE__ */ new Set(["fn", "spyOn"]);
+function isMockFactory(source, node) {
+  if (node.type !== "CallExpression") return false;
+  const callee = node.callee;
+  if (callee?.type !== "MemberExpression") return false;
+  const object = callee.object;
+  const property = callee.property;
+  if (object?.type !== "Identifier" || property?.type !== "Identifier") return false;
+  const runner = source.slice(object.start, object.end);
+  const method = source.slice(property.start, property.end);
+  return (runner === "jest" || runner === "vi") && MOCK_FACTORY.has(method);
+}
+function resolvedValue(source, executor) {
+  if (executor.type !== "ArrowFunctionExpression" && executor.type !== "FunctionExpression") {
+    return void 0;
+  }
+  const params = executor.params;
+  if (params?.length !== 1) return void 0;
+  const parameter = params[0];
+  if (parameter.type !== "Identifier") return void 0;
+  const resolveName = source.slice(parameter.start, parameter.end);
+  const body = executor.body;
+  if (body === void 0) return void 0;
+  let call;
+  if (body.type === "BlockStatement") {
+    const statements = body.body;
+    if (statements?.length !== 1) return void 0;
+    const only = statements[0];
+    if (only.type !== "ExpressionStatement") return void 0;
+    call = only.expression;
+  } else {
+    call = body;
+  }
+  if (call?.type !== "CallExpression") return void 0;
+  const callee = call.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  if (source.slice(callee.start, callee.end) !== resolveName) return void 0;
+  const args = call.arguments;
+  if (args?.length !== 1) return void 0;
+  return args[0];
+}
+function rewriteMockPromiseResolve(source, program) {
+  const edits = [];
+  walk(program, (node) => {
+    if (!isMockFactory(source, node)) return;
+    for (const argument of node.arguments ?? []) {
+      walk(argument, (inner) => {
+        if (inner.type !== "NewExpression") return;
+        const callee = inner.callee;
+        if (callee?.type !== "Identifier") return;
+        if (source.slice(callee.start, callee.end) !== "Promise") return;
+        if ((inner.typeArguments ?? inner.typeParameters) !== void 0) return;
+        const executors = inner.arguments ?? [];
+        if (executors.length !== 1) return;
+        const value = resolvedValue(source, executors[0]);
+        if (value === void 0) return;
+        edits.push({
+          start: inner.start,
+          end: inner.end,
+          text: `Promise.resolve(${source.slice(value.start, value.end)})`
+        });
+      });
+    }
+  });
+  let result = source;
+  for (const edit of [...edits].sort((left, right) => right.start - left.start)) {
+    result = `${result.slice(0, edit.start)}${edit.text}${result.slice(edit.end)}`;
+  }
+  return { source: result, rewritten: edits.length };
+}
+
 // src/roles/test/codemod/propagate-await.ts
 import { parseSync as parseSync5 } from "oxc-parser";
 var FUNCTIONS3 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
@@ -7256,6 +7328,8 @@ function repointMswServer(fileName, source) {
 
 // src/roles/test/codemod/spy-instance-type.ts
 var SPY_TYPES = /* @__PURE__ */ new Set(["SpyInstance"]);
+var QUALIFIED_ONLY = /* @__PURE__ */ new Set(["Mock"]);
+var VITEST_NAME = { SpyInstance: "MockInstance", Mock: "Mock" };
 function typeNameOf(source, node) {
   const name = node.typeName;
   if (name === void 0) return void 0;
@@ -7267,17 +7341,20 @@ function rewriteSpyInstanceType(source, program) {
     if (node.type !== "TSTypeReference") return;
     const written = typeNameOf(source, node);
     if (written === void 0) return;
-    const bare = written.startsWith("jest.") ? written.slice("jest.".length) : written;
-    if (!SPY_TYPES.has(bare)) return;
+    const qualified = written.startsWith("jest.");
+    const bare = qualified ? written.slice("jest.".length) : written;
+    if (!SPY_TYPES.has(bare) && !(qualified && QUALIFIED_ONLY.has(bare))) return;
     const args = (node.typeArguments ?? node.typeParameters)?.params;
     if (args === void 0 || args.length === 0) return;
     const text = (argument) => source.slice(argument.start, argument.end);
     const returns = text(args[0]);
     const parameters = args.length > 1 ? `...args: ${text(args[1])}` : "...args: never[]";
+    const target = VITEST_NAME[bare];
     edits.push({
       start: node.start,
       end: node.end,
-      text: `MockInstance<(${parameters}) => ${returns}>`
+      text: `${target}<(${parameters}) => ${returns}>`,
+      imports: target
     });
   });
   let result = source;
@@ -7287,7 +7364,8 @@ function rewriteSpyInstanceType(source, program) {
   return {
     source: result,
     rewritten: edits.length,
-    typeImports: edits.length > 0 ? ["MockInstance"] : []
+    // Only the names actually written, so a file does not import a type it never uses.
+    typeImports: [...new Set(edits.map((edit) => edit.imports))]
   };
 }
 
@@ -7375,7 +7453,10 @@ function migrateTestFile(fileName, source, defaultImported = /* @__PURE__ */ new
   const afterEmpty = parse2(fileName, emptyImplementations.source);
   if (afterEmpty === void 0) return unparsable("empty mock implementation");
   const hooks = rewriteHookReturnValue(emptyImplementations.source, afterEmpty);
-  const awaited = propagateAwait(fileName, hooks.source, original, asyncHelpers);
+  const afterHooks = parse2(fileName, hooks.source);
+  if (afterHooks === void 0) return unparsable("hook return value");
+  const promises = rewriteMockPromiseResolve(hooks.source, afterHooks);
+  const awaited = propagateAwait(fileName, promises.source, original, asyncHelpers);
   const program = parse2(fileName, awaited.source);
   if (program === void 0) return unparsable("hook body");
   const hoist = hoistCapturedBindings(
@@ -8208,17 +8289,17 @@ function specTypesOperation(cwd) {
     }
   };
 }
-function mockExtendedTypesPath(cwd) {
+function shippedTypesPath(cwd, declaration) {
   try {
     const manifest = createRequire6(join35(cwd, "noop.cjs")).resolve("@hublo/sentinel/package.json");
-    const file = join35(dirname7(manifest), MOCK_EXTENDED_TYPES);
+    const file = join35(dirname7(manifest), declaration);
     if (existsSync29(file)) {
       const path = relative7(cwd, file);
       return path.startsWith(".") ? path : `./${path}`;
     }
   } catch {
   }
-  return `./node_modules/@hublo/sentinel/${MOCK_EXTENDED_TYPES}`;
+  return `./node_modules/@hublo/sentinel/${declaration}`;
 }
 function tsconfigFileListOperations(cwd) {
   const operations = [];
@@ -8241,7 +8322,7 @@ function tsconfigFileListOperations(cwd) {
     const include = Array.isArray(config?.include) ? rewriteFileList(config.include) : void 0;
     const exclude = Array.isArray(config?.exclude) ? rewriteFileList(config.exclude) : void 0;
     const files = Array.isArray(config?.files) ? rewriteFileList(config.files) : void 0;
-    const withTypes = name === SPEC_TSCONFIG ? withMockExtendedTypes(cwd, files ?? config?.files) : void 0;
+    const withTypes = name === SPEC_TSCONFIG ? withShippedTypes(cwd, files ?? config?.files) : void 0;
     if (include === void 0 && exclude === void 0 && files === void 0 && withTypes === void 0)
       continue;
     operations.push({
@@ -8261,12 +8342,15 @@ function rewriteFileList(entries) {
   const unchanged = rewritten.length === entries.length && rewritten.every((entry, index) => entry === entries[index]);
   return unchanged ? void 0 : rewritten;
 }
-function withMockExtendedTypes(cwd, files) {
+function withShippedTypes(cwd, files) {
   const entries = Array.isArray(files) ? files : [];
-  if (entries.some((entry) => entry.endsWith(MOCK_EXTENDED_TYPES))) return void 0;
-  return [...entries, mockExtendedTypesPath(cwd)];
+  const missing = SHIPPED_TYPES.filter(
+    (declaration) => !entries.some((entry) => entry.endsWith(declaration))
+  );
+  if (missing.length === 0) return void 0;
+  return [...entries, ...missing.map((declaration) => shippedTypesPath(cwd, declaration))];
 }
-var MOCK_EXTENDED_TYPES = "types/mock-extended.d.ts";
+var SHIPPED_TYPES = ["types/mock-extended.d.ts", "types/jest-global.d.ts"];
 var JEST_CONFIG_ENTRY = /(^|\/)jest\.[\w.-]*config\.[cm]?[jt]s$/;
 var TSCONFIG_FILE = /^tsconfig[\w.-]*\.json$/;
 function siblingScriptRewrites(cwd) {

package/dist/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hublo/sentinel",
-  "version": "1.4.0-alpha.14",
+  "version": "1.4.0-alpha.16",
   "description": "One CLI that guards code health across Hublo repos: shared lint/typescript/build/test presets, static & dynamic analysis, and architecture checks.",
   "type": "module",
   "license": "MIT",

package/types/jest-global.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The type-level half of the `jest` global the setup installs.
+ *
+ * ## What it pairs with
+ *
+ * The migration rewrites SPEC files and deliberately leaves helpers alone, because the setup puts
+ * Vitest's `vi` on `globalThis` under the name `jest`:
+ *
+ *     // setup/jest-global.ts
+ *     ;(globalThis as Record<string, unknown>).jest = vi
+ *
+ * That is what lets a module migrate on its own while a shared helper still calls `jest.fn()`, and
+ * it is why the suite of a migrated module is green with untouched helpers.
+ *
+ * The shim answers the RUNTIME. It says nothing to TypeScript, and the migration also replaces
+ * `"jest"` with `"vitest/globals"` in the module's `tsconfig.spec.json`, so the name stops being a
+ * value at compile time while it still is one at run time.
+ *
+ * Measured on `apps/nest/microservices/institution` with alpha.14, a module whose typecheck was
+ * green before it migrated and whose 2958 tests all pass after:
+ *
+ *     src/app/institution.test-wrapper.ts(83,22)
+ *       error TS2708: Cannot use namespace 'jest' as a value.
+ *     tests/support/institution-prisma.test-wrapper.ts(58,22)
+ *       error TS2708: Cannot use namespace 'jest' as a value.
+ *
+ * Both are helpers, neither is a spec, and both run correctly. This file states, for the type
+ * checker, exactly what the setup states for the runtime.
+ *
+ * ## Why `typeof vi` and not a hand-written subset
+ *
+ * The shim assigns the whole `vi`, so anything narrower would describe something the module does
+ * not run. Writing the truth costs one line and cannot drift.
+ *
+ * ## In a program that still carries `@types/jest`
+ *
+ * No conflict, and this one wins: measured on a fixture holding both, `jest.hoisted(() => 1)`
+ * compiles, and `hoisted` exists only on `vi`. So a module part-way through its migration gets the
+ * type of what actually executes rather than the type of the runner it is leaving.
+ */
+declare const jest: (typeof import('vitest'))['vi']