@hublo/sentinel 1.2.0-alpha.4 → 1.2.0-alpha.40

package/dist/bin/sentinel.d.ts

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

package/dist/bin/sentinel.js

@@ -8,6 +8,8 @@ import {
   VERBS,
   WORKSPACE_ROOT_MARKER,
   availableTargets,
+  buildConfigFile,
+  contradictingPreset,
   declaredPresetFor,
   describeFramework,
   dispatch,
@@ -21,7 +23,7 @@ import {
   registerAdapters,
   resolve,
   resolveBin
-} from "../chunk-6DBTDMSN.js";
+} from "../chunk-PBCVWRXM.js";
 
 // bin/sentinel.ts
 import { program } from "commander";
@@ -113,6 +115,30 @@ function resolveContext(cwd2, opts2) {
   );
 }
 
+// src/roles/build/declined.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+var DEPRECATED_NX_BUILDER = "@nx/webpack:webpack";
+function buildsWithDeprecatedExecutor(cwd2) {
+  const projectJson = join3(cwd2, "project.json");
+  if (!existsSync2(projectJson)) return false;
+  try {
+    const project = JSON.parse(readFileSync2(projectJson, "utf8"));
+    return project.targets?.build?.executor === DEPRECATED_NX_BUILDER;
+  } catch {
+    return false;
+  }
+}
+function explainDecline(cwd2) {
+  if (buildConfigFile(cwd2) !== void 0) {
+    return ` This module HAS a Vite config, so detection is the likely problem: the build toolchain is declared at the workspace root, which makes a front app detect as "node". Pass --preset to say what it is.`;
+  }
+  if (buildsWithDeprecatedExecutor(cwd2)) {
+    return ` This module still builds through ${DEPRECATED_NX_BUILDER}, which Nx v24 removes. It has no Vite config yet, so there is nothing for --build to adopt: add one that imports @hublo/sentinel/build/nest, then run this again. See docs/build-adoption.md.`;
+  }
+  return ` This module has neither a Vite config nor an Nx build target, so it builds nothing and --build is out of scope for it. Nothing was written, and nothing is wrong.`;
+}
+
 // src/cli/run-init.ts
 function asMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -151,9 +177,10 @@ async function runInit(ctx) {
     } catch (error) {
       if (error instanceof PresetUnsupportedError) {
         if (ctx.targetsExplicit) {
+          const hint = type === "build" ? explainDecline(module.root) : ` Pass --preset if it was detected wrongly (hoisted dependencies make detection fall back to "node").`;
           process.stderr.write(
             `
-sentinel (${type}): this module's preset is "${error.preset}", and --${type} has no adapter for it. Pass --preset if it was detected wrongly (hoisted dependencies make detection fall back to "node").
+sentinel (${type}): this module's preset is "${error.preset}", and --${type} has no adapter for it.${hint}
 `
           );
           worst = Math.max(worst, 1);
@@ -212,7 +239,9 @@ async function analyse(params) {
     }
     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 ?? contradictingPreset(module.root, preset2)?.preset ?? preset2;
+      const resolutionPreset = corrected;
       try {
         adapter = resolve(target, resolutionPreset, params.runner);
       } catch (error) {

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

package/dist/chunk-NKFGYPIQ.js

@@ -0,0 +1,13 @@
+// src/roles/test/setup/msw.ts
+import { setupServer } from "msw/node";
+var server = setupServer();
+function installMswLifecycle(hooks) {
+  hooks.beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
+  hooks.afterAll(() => server.close());
+}
+
+export {
+  server,
+  installMswLifecycle
+};
+//# sourceMappingURL=chunk-NKFGYPIQ.js.map