@tsed/cli 7.2.1 → 7.3.0

package/lib/esm/commands/init/InitCmd.js

@@ -1,3 +1,4 @@
+import * as os from "node:os";
 import { basename, join } from "node:path";
 import { CliExeca, CliFs, CliLoadFile, cliPackageJson, CliPlugins, command, Configuration, inject, PackageManagersModule, ProjectPackageJson } from "@tsed/cli-core";
 import { tasks } from "@tsed/cli-tasks";
@@ -14,10 +15,12 @@ import { RuntimesModule } from "../../runtimes/RuntimesModule.js";
 import { BunRuntime } from "../../runtimes/supports/BunRuntime.js";
 import { NodeRuntime } from "../../runtimes/supports/NodeRuntime.js";
 import { CliProjectService } from "../../services/CliProjectService.js";
+import { anonymizePaths } from "../../services/mappers/anonymizePaths.js";
 import { FeaturesMap, FeatureType } from "./config/FeaturesPrompt.js";
 import { InitSchema } from "./config/InitSchema.js";
 import { mapToContext } from "./mappers/mapToContext.js";
 import { getFeaturesPrompt } from "./prompts/getFeaturesPrompt.js";
+const ISSUE_URL = "https://github.com/tsedio/tsed-cli/issues/new";
 export class InitCmd {
     constructor() {
         this.configuration = inject(Configuration);
@@ -320,6 +323,55 @@ export class InitCmd {
         await Promise.all(promises);
         taskOutput(`Plugins files rendered (${Date.now() - startTime}ms)`);
     }
+    $onFinish(data, er) {
+        if (data.commandName !== "init" || !er) {
+            return;
+        }
+        console.error(["", `Init failed. Please open an issue: ${ISSUE_URL}`, "", "Copy/paste this report:", this.buildIssueReport(data, er)].join("\n"));
+    }
+    buildIssueReport(data, er) {
+        const sanitizedMessage = anonymizePaths(er.message || "");
+        const sanitizedStack = anonymizePaths(er.stack || "");
+        const command = ["tsed", "init", ...(data.rawArgs || [])].join(" ");
+        const convention = this.packageJson.preferences.convention === "conv_default" ? "tsed" : "angular";
+        const style = this.packageJson.preferences.architecture === "arc_default" ? "tsed" : "feature";
+        const platform = this.packageJson.preferences.platform || "";
+        const packageManager = this.packageJson.preferences.packageManager || "";
+        const runtime = this.packageJson.preferences.runtime || "";
+        const tsedVersion = this.packageJson.dependencies["@tsed/platform-http"] || "";
+        const channel = "cli";
+        const cliVersion = this.cliPackageJson.version || "";
+        const osType = os.type();
+        const features = data.features || [];
+        return [
+            "## Environment",
+            `- @tsed/cli version: ${this.cliPackageJson.version}`,
+            `- Node.js version: ${process.version}`,
+            `- Platform: ${process.platform} ${process.arch}`,
+            `- Command: \`${command}\``,
+            "",
+            "## Init Stats",
+            `- tsed_version: ${tsedVersion}`,
+            `- platform: ${platform}`,
+            `- convention: ${convention}`,
+            `- style: ${style}`,
+            `- package_manager: ${packageManager}`,
+            `- runtime: ${runtime}`,
+            `- features: ${features.join(", ")}`,
+            `- channel: ${channel}`,
+            `- cli_version: ${cliVersion}`,
+            `- os: ${osType}`,
+            "",
+            "## Error",
+            `- Name: ${er.name || "Error"}`,
+            `- Message: ${sanitizedMessage || "(empty)"}`,
+            "",
+            "## Stack",
+            "```txt",
+            sanitizedStack || "(empty)",
+            "```"
+        ].join("\n");
+    }
 }
 command({
     token: InitCmd,

package/lib/esm/services/CliStats.js

@@ -1,6 +1,7 @@
 import { CliHttpClient, ProjectPackageJson } from "@tsed/cli-core";
 import { constant, inject, injectable } from "@tsed/di";
 import * as os from "os";
+import { anonymizePaths } from "./mappers/anonymizePaths.js";
 export class CliStats extends CliHttpClient {
     constructor() {
         super(...arguments);
@@ -16,7 +17,7 @@ export class CliStats extends CliHttpClient {
                 ...opts,
                 os: os.type(),
                 convention: this.projectPackage.preferences.convention === "conv_default" ? "tsed" : "angular",
-                style: this.projectPackage.preferences.architecture === "arc_default" ? "tsed" : "angular",
+                style: this.projectPackage.preferences.architecture === "arc_default" ? "tsed" : "feature",
                 platform: this.projectPackage.preferences.platform,
                 package_manager: this.projectPackage.preferences.packageManager,
                 runtime: this.projectPackage.preferences.runtime,
@@ -33,11 +34,13 @@ export class CliStats extends CliHttpClient {
     }
     $onFinish(data, er) {
         if (data.commandName === "init") {
+            const sanitizedMessage = anonymizePaths(er?.message || "");
+            const sanitizedStack = anonymizePaths(er?.stack || "");
             return this.sendInit({
                 channel: "cli",
                 is_success: !er,
                 error_name: er?.name || "",
-                error_message: er?.message,
+                error_message: [sanitizedMessage, sanitizedStack].filter(Boolean).join(" "),
                 features: data.features
             });
         }

package/lib/esm/services/mappers/anonymizePaths.js

@@ -0,0 +1,73 @@
+import { homedir } from "node:os";
+import { basename, relative, resolve } from "node:path";
+const GLOBAL_MODULE_MARKER = "/node_modules/";
+function toPosixPath(pathname) {
+    return pathname.replace(/\\/g, "/");
+}
+function normalizePath(pathname) {
+    return toPosixPath(resolve(pathname));
+}
+function isSubPath(pathname, parentPath) {
+    return pathname === parentPath || pathname.startsWith(`${parentPath}/`);
+}
+function splitPathAndLocation(pathname) {
+    const match = pathname.match(/^(.*?)(:\d+(?::\d+)?)?$/);
+    return {
+        path: match?.[1] || pathname,
+        location: match?.[2] || ""
+    };
+}
+function getGlobalModulePath(absolutePath, absolutePathForCompare) {
+    const index = absolutePathForCompare.indexOf(GLOBAL_MODULE_MARKER);
+    if (index === -1) {
+        return;
+    }
+    const pathAfterNodeModules = absolutePath.slice(index + GLOBAL_MODULE_MARKER.length);
+    const segments = pathAfterNodeModules.split("/").filter(Boolean);
+    if (!segments.length) {
+        return;
+    }
+    const isScoped = segments[0].startsWith("@");
+    const moduleName = isScoped ? segments.slice(0, 2).join("/") : segments[0];
+    if (!moduleName || (isScoped && segments.length < 2)) {
+        return;
+    }
+    const suffixSegments = segments.slice(isScoped ? 2 : 1);
+    const suffix = suffixSegments.length ? `/${suffixSegments.join("/")}` : "";
+    return `<global>/${moduleName}${suffix}`;
+}
+function anonymizeAbsolutePath(pathname, cwd, home) {
+    const absolutePath = normalizePath(pathname);
+    const absolutePathForCompare = absolutePath.toLowerCase();
+    const cwdForCompare = cwd.toLowerCase();
+    const homeForCompare = home.toLowerCase();
+    if (isSubPath(absolutePathForCompare, cwdForCompare)) {
+        const relativePath = toPosixPath(relative(cwd, absolutePath));
+        return relativePath ? `<cwd>/${relativePath}` : "<cwd>";
+    }
+    const globalModulePath = getGlobalModulePath(absolutePath, absolutePathForCompare);
+    if (globalModulePath) {
+        return globalModulePath;
+    }
+    if (isSubPath(absolutePathForCompare, homeForCompare)) {
+        return `~/${toPosixPath(relative(home, absolutePath))}`;
+    }
+    return `<external>/${basename(absolutePath)}`;
+}
+function anonymizeTokenWithContext(token, cwd, home) {
+    const { path, location } = splitPathAndLocation(token);
+    return `${anonymizeAbsolutePath(path, cwd, home)}${location}`;
+}
+function toPathFromFileUrl(token) {
+    const decodedPath = decodeURIComponent(token.replace(/^file:\/\//, ""));
+    return decodedPath.replace(/^\/([A-Za-z]:[\\/])/, "$1");
+}
+export function anonymizePaths(stack, options = {}) {
+    const cwd = normalizePath(options.cwd || process.cwd());
+    const home = normalizePath(options.home || homedir());
+    return stack
+        .replace(/file:\/\/\/[^\s)]+/g, (token) => anonymizeTokenWithContext(toPathFromFileUrl(token), cwd, home))
+        .replace(/(^|[\s(])((?:[A-Za-z]:\\|\/)[^\s)]+)/g, (_full, prefix, token) => {
+        return `${prefix}${anonymizeTokenWithContext(token, cwd, home)}`;
+    });
+}