@hublo/sentinel 1.2.0 → 1.4.0-alpha.1

package/README.md

@@ -395,6 +395,8 @@ VERBS      --run       execute the target's tool (--json for metrics + diagnosti
 TYPES      --lint  --format  --typescript  --build  --dev  --test
            --static-analysis  --runtime-analysis  --arch
            (omit a type → every type that TERMINATES; --dev never sweeps)
+           --dev answers --run and --init only: a server is started, not read,
+           so --inspect/--report/--status refuse it and point at --build
 
 LOCATION   in a MODULE dir      → that module (do NOT pass --module)
            at the workspace ROOT → --module <name> (one) · --ci (affected) · else all

package/dist/bin/sentinel.d.ts

@@ -4,4 +4,3 @@ import '@vitejs/plugin-react';
 import 'nitro/vite';
 import 'vite-plugin-svgr';
 import 'vite';
-import 'vitest/config';

package/dist/bin/sentinel.js

@@ -6,23 +6,26 @@ import {
   SWEEPABLE_TARGETS,
   TARGETS,
   VERBS,
-  WORKSPACE_ROOT_MARKER,
   availableTargets,
   buildConfigFile,
+  correctingSignal,
   declaredPresetFor,
   describeFramework,
   dispatch,
+  palette,
+  registerAdapters,
+  resolve,
+  resolveBin
+} from "../chunk-O3XCQGTJ.js";
+import {
+  WORKSPACE_ROOT_MARKER,
   ensureWorkspacePrep,
   findWorkspaceRoot,
   inspectWorkspacePrep,
   moduleName,
-  palette,
   readOwnVersion,
-  readProjectPackageJson,
-  registerAdapters,
-  resolve,
-  resolveBin
-} from "../chunk-Z5I6SEKF.js";
+  readProjectPackageJson
+} from "../chunk-WLFE5RUU.js";
 
 // bin/sentinel.ts
 import { program } from "commander";
@@ -235,10 +238,13 @@ async function analyse(params) {
           ) + "\n"
         );
       }
+      preset2 = correctingSignal(preset2, module.root)?.preset ?? preset2;
     }
     for (const target of params.targets) {
       let adapter;
-      const resolutionPreset = params.preset ?? declaredPresetFor(target, module.root) ?? preset2;
+      const declared = declaredPresetFor(target, module.root);
+      const corrected = params.preset ?? declared ?? correctingSignal(preset2, module.root)?.preset ?? preset2;
+      const resolutionPreset = corrected;
       try {
         adapter = resolve(target, resolutionPreset, params.runner);
       } catch (error) {
@@ -490,6 +496,16 @@ async function runVerb(ctx) {
   const out = palette(process.stdout);
   const err = palette(process.stderr);
   const longRunning = ctx.targets.filter((target) => LONG_RUNNING_TARGETS.includes(target));
+  const READ_VERBS = ["inspect", "report", "status"];
+  if (longRunning.length > 0 && READ_VERBS.includes(ctx.verb)) {
+    const flags = longRunning.map((target) => `--${target}`).join(", ");
+    process.stderr.write(
+      err.fail(
+        `sentinel: ${flags} starts a server, so there is nothing to read about it. Its config and resolution are the build's: use \`sentinel --${ctx.verb} --build\`. \`sentinel --init --dev\` adopts it, and writes both scripts.`
+      ) + "\n"
+    );
+    return 1;
+  }
   if (longRunning.length > 0 && modules.length > 1) {
     process.stderr.write(
       err.fail(
@@ -655,7 +671,10 @@ program.name("sentinel").description("One CLI that guards code health: presets,
     "  sentinel --run --json                              # from root \u2192 all types, machine output",
     "  sentinel --run --ci                                # from root \u2192 affected only",
     "  sentinel --inspect --typescript                    # from root \u2192 adoption + what is deferred",
-    "  sentinel --init --preset react                     # adopt EVERY role: lint, format, typescript",
+    // Deliberately not enumerated here. A hand-written list drifts, and this one did: it
+    // still said "lint, format, typescript" after the build role shipped, so the help told
+    // adopters the build was not covered when it was. "Available now", below, is derived.
+    "  sentinel --init --preset react                     # adopt every available role (see below)",
     "  sentinel --init --typescript --preset react       # set up the current module + workspace",
     "  sentinel --run --typescript -- --noImplicitAny     # ask the tool a question of your own"
   ].join("\n")

package/dist/chunk-2XLX6PFR.js

@@ -0,0 +1,132 @@
+// src/roles/test/setup/mock-extended.ts
+import * as mockExtended from "vitest-mock-extended";
+export * from "vitest-mock-extended";
+import {
+  any,
+  anyArray,
+  anyBoolean,
+  anyFunction,
+  anyMap,
+  anyNumber,
+  anyObject,
+  anySet,
+  anyString,
+  anySymbol,
+  arrayIncludes,
+  calledWithFn,
+  captor,
+  isA,
+  isMockObject,
+  mapHas,
+  matches,
+  mockClear as mockClear2,
+  mocked,
+  mockedFn,
+  mockFn,
+  mockReset as mockReset2,
+  notEmpty,
+  notNull,
+  notUndefined,
+  objectContainsKey
+} from "vitest-mock-extended";
+var NEVER_MATERIALISED = /* @__PURE__ */ new Set(["then", "asymmetricMatch", "$$typeof", "nodeType"]);
+function materialise(target, key) {
+  if (typeof key !== "string" || NEVER_MATERIALISED.has(key)) return;
+  void target[key];
+}
+var wrappers = /* @__PURE__ */ new WeakMap();
+function answeringProxy(mock3) {
+  return new Proxy(mock3, {
+    /*
+     * A NESTED mock has to answer the same questions as the top-level one.
+     *
+     * The adapter used to wrap only what `mockDeep()` returned, and the level below it was a raw
+     * mock again. Measured: `'deleteMany' in db.timeSlot` answered false and its descriptor was
+     * absent, so `vi.spyOn(db.timeSlot, 'deleteMany')` failed with
+     * `The property "deleteMany" is not defined on the function` — the exact error
+     * `apps/nest/microservices/hublo-pool` reports, and the exact failure this adapter was written
+     * to remove, one level down.
+     *
+     * Read from the TARGET, never with this proxy as the receiver: forwarding the receiver changes
+     * what the deep mock hands back.
+     */
+    get(target, key) {
+      if (typeof key === "string" && NEVER_MATERIALISED.has(key)) return void 0;
+      const value = Reflect.get(target, key);
+      if (value === null) return value;
+      if (typeof value !== "object" && typeof value !== "function") return value;
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+      if (descriptor !== void 0 && descriptor.configurable === false && descriptor.writable === false) {
+        return value;
+      }
+      const existing = wrappers.get(value);
+      if (existing !== void 0) return existing;
+      const wrapper = answeringProxy(value);
+      wrappers.set(value, wrapper);
+      return wrapper;
+    },
+    has(target, key) {
+      if (Reflect.has(target, key)) return true;
+      materialise(target, key);
+      return Reflect.has(target, key);
+    },
+    getOwnPropertyDescriptor(target, key) {
+      const existing = Reflect.getOwnPropertyDescriptor(target, key);
+      if (existing !== void 0) return existing;
+      materialise(target, key);
+      return Reflect.getOwnPropertyDescriptor(target, key);
+    }
+  });
+}
+var REGISTRY = /* @__PURE__ */ Symbol.for("@hublo/sentinel/deep-mocks");
+var handedOut = globalThis[REGISTRY] ??= /* @__PURE__ */ new Set();
+function resetDeepMocks() {
+  for (const created of handedOut) mockExtended.mockReset(created);
+}
+function clearDeepMocks() {
+  for (const created of handedOut) mockExtended.mockClear(created);
+}
+var mock2 = ((...args) => {
+  const created = mockExtended.mock(...args);
+  handedOut.add(created);
+  return answeringProxy(created);
+});
+var mockDeep2 = ((...args) => {
+  const created = mockExtended.mockDeep(...args);
+  handedOut.add(created);
+  return answeringProxy(created);
+});
+
+export {
+  resetDeepMocks,
+  clearDeepMocks,
+  mock2 as mock,
+  mockDeep2 as mockDeep,
+  any,
+  anyArray,
+  anyBoolean,
+  anyFunction,
+  anyMap,
+  anyNumber,
+  anyObject,
+  anySet,
+  anyString,
+  anySymbol,
+  arrayIncludes,
+  calledWithFn,
+  captor,
+  isA,
+  isMockObject,
+  mapHas,
+  matches,
+  mockClear2 as mockClear,
+  mocked,
+  mockedFn,
+  mockFn,
+  mockReset2 as mockReset,
+  notEmpty,
+  notNull,
+  notUndefined,
+  objectContainsKey
+};
+//# sourceMappingURL=chunk-2XLX6PFR.js.map

package/dist/chunk-3TDUIKVQ.js

@@ -0,0 +1,178 @@
+// src/roles/build/nest/decorator-metadata.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+var TYPESCRIPT_SOURCE = /\.ts$/;
+var TSCONFIG_CANDIDATES = ["tsconfig.app.json", "tsconfig.json"];
+function loadCompiler(root) {
+  const require2 = createRequire(path.join(root, "noop.js"));
+  let compiler;
+  try {
+    compiler = require2("typescript");
+  } catch {
+    throw new Error(
+      `sentinel build(nest): no \`typescript\` resolvable from ${root}. The build emits decorator metadata with the module's own compiler, so one has to be installed there.`
+    );
+  }
+  if (typeof compiler.createProgram !== "function") {
+    throw new Error(
+      `sentinel build(nest): the typescript resolved from ${root} (${compiler.version ?? "unknown"}) has no createProgram API. TypeScript 7 is the native port and exposes none; the emit API lives under @typescript/typescript6. Point this module's \`typescript\` at a compiler with an emit API, which is the one its \`typecheck\` target already uses.`
+    );
+  }
+  return compiler;
+}
+function resolveTsconfig(options) {
+  if (options.tsconfig) {
+    const explicit = path.resolve(options.root, options.tsconfig);
+    if (!existsSync(explicit)) {
+      throw new Error(`sentinel build(nest): tsconfig not found at ${explicit}`);
+    }
+    return explicit;
+  }
+  for (const candidate of TSCONFIG_CANDIDATES) {
+    const found = path.join(options.root, candidate);
+    if (existsSync(found)) return found;
+  }
+  throw new Error(
+    `sentinel build(nest): no ${TSCONFIG_CANDIDATES.join(" or ")} in ${options.root}. Pass \`tsconfig\` if this service keeps it elsewhere.`
+  );
+}
+function readConfig(ts, options) {
+  const configPath = resolveTsconfig(options);
+  const parsed = ts.getParsedCommandLineOfConfigFile(configPath, {}, {
+    ...ts.sys,
+    onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
+      throw new Error(
+        `sentinel build(nest): could not read ${configPath}: ` + ts.flattenDiagnosticMessageText(diagnostic.messageText, " ")
+      );
+    }
+  });
+  return {
+    fileNames: parsed?.fileNames ?? [],
+    compilerOptions: {
+      ...parsed?.options,
+      // ESM out, so Rollup sees imports and exports rather than an opaque `require` it cannot
+      // follow. The service still SHIPS as CJS: that conversion is the bundler's, further down.
+      module: ts.ModuleKind.ESNext,
+      // Vite consumes the map; the tsconfig's own answer is about a different pipeline.
+      sourceMap: true,
+      inlineSourceMap: false,
+      inlineSources: false,
+      // Types are another target's job, and emitting them here would write into the source tree.
+      declaration: false,
+      declarationMap: false,
+      emitDeclarationOnly: false,
+      noEmit: false,
+      // `composite` projects refuse to emit without a `tsBuildInfoFile`, and there is no
+      // incremental build here to inform.
+      composite: false,
+      incremental: false
+    }
+  };
+}
+function loadTransformers(root, program, declared) {
+  const require2 = createRequire(path.join(root, "noop.js"));
+  return declared.map(({ name, options }) => {
+    let loaded;
+    try {
+      loaded = require2(name);
+    } catch (error) {
+      throw new Error(
+        `sentinel build(nest): the build target declares the transformer \`${name}\`, which cannot be loaded from ${root}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+    if (typeof loaded.before !== "function") {
+      throw new Error(
+        `sentinel build(nest): \`${name}\` exports no \`before\` factory, so it cannot run as a TypeScript transformer. Building without it would drop whatever it contributes.`
+      );
+    }
+    const factory = loaded.before;
+    return factory(options, program);
+  });
+}
+var decoratorMetadata = (options) => {
+  const typeAware = (options.transformers ?? []).length > 0;
+  let ts;
+  let program;
+  let compilerOptions;
+  let before = [];
+  const withoutTypes = [];
+  return {
+    name: "sentinel:decorator-metadata",
+    // Before Vite's own transform, so esbuild never sees the decorators it cannot handle, and so
+    // the source this plugin reads from the Program is still the source on disk.
+    enforce: "pre",
+    buildStart() {
+      ts = loadCompiler(options.root);
+      const config = readConfig(ts, options);
+      compilerOptions = config.compilerOptions;
+      if (!typeAware) return;
+      program = ts.createProgram(config.fileNames, config.compilerOptions);
+      before = loadTransformers(options.root, program, options.transformers ?? []);
+    },
+    transform(code, id) {
+      if (!TYPESCRIPT_SOURCE.test(id) || id.includes("node_modules")) return null;
+      if (ts === void 0 || compilerOptions === void 0) {
+        throw new Error(
+          `sentinel build(nest): the compiler was never prepared, so ${id} would be emitted with defaults rather than this module's tsconfig.`
+        );
+      }
+      const sourceFile = program?.getSourceFile(id);
+      if (program === void 0 || sourceFile === void 0 || sourceFile.text !== code) {
+        if (typeAware) withoutTypes.push(id);
+        const output = ts.transpileModule(code, { fileName: id, compilerOptions });
+        return { code: output.outputText, map: output.sourceMapText ?? null };
+      }
+      let emitted;
+      let map;
+      program.emit(
+        sourceFile,
+        (fileName, text) => {
+          if (fileName.endsWith(".map")) map = text;
+          else emitted = text;
+        },
+        void 0,
+        false,
+        { before }
+      );
+      if (emitted === void 0) {
+        throw new Error(`sentinel build(nest): TypeScript emitted nothing for ${id}.`);
+      }
+      return { code: emitted, map: map ?? null };
+    },
+    closeBundle() {
+      if (withoutTypes.length === 0) return;
+      const shown = withoutTypes.slice(0, 5).map((file) => path.relative(options.root, file));
+      this.warn(
+        `sentinel build(nest): ${withoutTypes.length} file(s) were emitted without type information, so their decorator metadata may differ from what ts-loader produced (${shown.join(", ")}${withoutTypes.length > shown.length ? ", \u2026" : ""}). They are outside this module's tsconfig, or another plugin rewrote them first.`
+      );
+    }
+  };
+};
+
+// src/roles/build/nest/tsconfig-aliases.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+var stripLineComments = (json) => json.replace(/^\s*\/\/.*$/gm, "");
+var toAlias = (workspaceRoot, pattern, target) => {
+  const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, "(.*)");
+  return {
+    find: new RegExp(`^${escaped}$`),
+    replacement: join(workspaceRoot, target.replace(/\*/g, "$1"))
+  };
+};
+var tsconfigAliases = (workspaceRoot, file = "tsconfig.base.json") => {
+  const raw = readFileSync(join(workspaceRoot, file), "utf8");
+  const { compilerOptions } = JSON.parse(stripLineComments(raw));
+  return Object.entries(compilerOptions?.paths ?? {}).flatMap(([pattern, targets]) => {
+    const [target] = targets;
+    return target === void 0 ? [] : [toAlias(workspaceRoot, pattern, target)];
+  }).sort((a, b) => b.find.source.length - a.find.source.length);
+};
+
+export {
+  decoratorMetadata,
+  tsconfigAliases
+};
+//# sourceMappingURL=chunk-3TDUIKVQ.js.map