feat(util-user-agent-node): populate typescript version in user agent when available (#7786)

Author: trivikr

packages-internal/util-user-agent-node/src/defaultUserAgent.spec.ts

@@ -5,10 +5,12 @@ import { afterEach, beforeEach, describe, expect, test as it, vi } from "vitest"
 import type { PreviouslyResolved } from "./defaultUserAgent";
 import { createDefaultUserAgentProvider } from "./defaultUserAgent";
 import { getRuntimeUserAgentPair } from "./getRuntimeUserAgentPair";
+import { getTypeScriptUserAgentPair } from "./getTypeScriptUserAgentPair";
 import { isCrtAvailable } from "./is-crt-available";
 
 vi.mock("os");
 vi.mock("./getRuntimeUserAgentPair");
+vi.mock("./getTypeScriptUserAgentPair");
 vi.mock("./is-crt-available");
 
 const validateUserAgent = (userAgent: UserAgent, expected: UserAgent) => {
@@ -25,6 +27,7 @@ describe("createDefaultUserAgentProvider", () => {
     vi.mocked(platform).mockReturnValue("darwin");
     vi.mocked(release).mockReturnValue("19.6.0");
     vi.mocked(getRuntimeUserAgentPair).mockReturnValue(["md/nodejs", "20.0.0"]);
+    vi.mocked(getTypeScriptUserAgentPair).mockResolvedValue(undefined);
     vi.mocked(isCrtAvailable).mockReturnValue(null);
     delete process.env.AWS_EXECUTION_ENV;
   });
@@ -53,6 +56,13 @@ describe("createDefaultUserAgentProvider", () => {
     validateUserAgent(userAgent, basicUserAgent);
   });
 
+  it("should add typescript version if available", async () => {
+    vi.mocked(getTypeScriptUserAgentPair).mockResolvedValue(["md/tsc", "5.9.3"]);
+    const userAgentProvider = createDefaultUserAgentProvider({ serviceId: "s3", clientVersion: "0.1.0" });
+    const userAgent = await userAgentProvider(mockConfig);
+    expect(userAgent).toContainEqual(["md/tsc", "5.9.3"]);
+  });
+
   it("should set crt available key if aws-crt is available in runtime", async () => {
     vi.mocked(isCrtAvailable).mockReturnValue(["md/crt-avail"]);
     const userAgentProvider = createDefaultUserAgentProvider({ serviceId: "s3", clientVersion: "0.1.0" });

packages-internal/util-user-agent-node/src/defaultUserAgent.ts

@@ -3,6 +3,7 @@ import { platform, release } from "node:os";
 import { env } from "node:process";
 
 import { getRuntimeUserAgentPair } from "./getRuntimeUserAgentPair";
+import { getTypeScriptUserAgentPair } from "./getTypeScriptUserAgentPair";
 import { isCrtAvailable } from "./is-crt-available";
 
 /**
@@ -45,6 +46,11 @@ export const createDefaultUserAgentProvider = ({ serviceId, clientVersion }: Def
       runtimeUserAgentPair,
     ];
 
+    const typescriptUserAgentPair = await getTypeScriptUserAgentPair();
+    if (typescriptUserAgentPair) {
+      sections.push(typescriptUserAgentPair);
+    }
+
     const crtAvailable = isCrtAvailable();
     if (crtAvailable) {
       sections.push(crtAvailable);

packages-internal/util-user-agent-node/src/getTypeScriptPackageJsonPath.spec.ts

@@ -0,0 +1,35 @@
+import { join, sep } from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { getTypeScriptPackageJsonPath } from "./getTypeScriptPackageJsonPath";
+
+describe(getTypeScriptPackageJsonPath.name, () => {
+  it("returns node_modules/typescript/package.json when dirname is empty", () => {
+    expect(getTypeScriptPackageJsonPath()).toBe(join("node_modules", "typescript", "package.json"));
+  });
+
+  it("returns path relative to dirname when not inside node_modules", () => {
+    const dirname = join("some", "path");
+    expect(getTypeScriptPackageJsonPath(dirname)).toBe(join(dirname, "node_modules", "typescript", "package.json"));
+  });
+
+  it("returns path relative to first node_modules when inside node_modules", () => {
+    const dirname = join("project", "node_modules", "@aws-sdk", "client-s3");
+    expect(getTypeScriptPackageJsonPath(dirname)).toBe(join("project", "node_modules", "typescript", "package.json"));
+  });
+
+  it("handles nested node_modules by using the first occurrence", () => {
+    const dirname = join("project", "node_modules", "pkg", "node_modules", "nested");
+    expect(getTypeScriptPackageJsonPath(dirname)).toBe(join("project", "node_modules", "typescript", "package.json"));
+  });
+
+  it.each([
+    [["foo", "."].join(sep), "foo"],
+    [["foo", "..", "bar"].join(sep), "bar"],
+    [["foo", ".", "bar"].join(sep), join("foo", "bar")],
+  ])("normalizes mixed path separators for '%s'", (dirname, nodeModulesPath) => {
+    expect(getTypeScriptPackageJsonPath(dirname)).toBe(
+      join(nodeModulesPath, "node_modules", "typescript", "package.json")
+    );
+  });
+});

packages-internal/util-user-agent-node/src/getTypeScriptPackageJsonPath.ts

@@ -0,0 +1,32 @@
+import { join, normalize, sep } from "node:path";
+
+/**
+ * Returns the path to the TypeScript package.json file relative to the given directory.
+ *
+ * @param dirname - The directory path to resolve from.
+ * @returns The path to the TypeScript package.json file.
+ *
+ * @internal
+ */
+export const getTypeScriptPackageJsonPath = (dirname = ""): string => {
+  let nodeModulesPath: string;
+
+  // Normalize the path to handle mixed separators
+  const normalizedPath = normalize(dirname);
+
+  // Split into parts
+  const parts = normalizedPath.split(sep);
+
+  // Find the index of the first "node_modules" segment
+  const nodeModulesIndex = parts.indexOf("node_modules");
+
+  if (nodeModulesIndex !== -1) {
+    // If we are inside node_modules, we use the first occurrence of 'node_modules'
+    nodeModulesPath = parts.slice(0, nodeModulesIndex).join(sep);
+  } else {
+    // If we are not inside node_modules, we can use the current directory.
+    nodeModulesPath = dirname;
+  }
+
+  return join(nodeModulesPath, "node_modules", "typescript", "package.json");
+};

packages-internal/util-user-agent-node/src/getTypeScriptUserAgentPair.spec.ts

@@ -0,0 +1,102 @@
+import { readFile } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { getTypeScriptPackageJsonPath } from "./getTypeScriptPackageJsonPath";
+
+vi.mock("node:fs/promises");
+vi.mock("./getTypeScriptPackageJsonPath");
+
+describe("getTypeScriptUserAgentPair", () => {
+  const mockTscVersion = "5.9.3";
+  const mockPackageJsonPath = "/mock/node_modules/typescript/package.json";
+
+  beforeEach(() => {
+    vi.mocked(getTypeScriptPackageJsonPath).mockReturnValue(mockPackageJsonPath);
+  });
+
+  afterEach(() => {
+    expect(readFile).toHaveBeenCalledWith(mockPackageJsonPath, "utf-8");
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  describe("when typescript/package.json is available", () => {
+    beforeEach(() => {
+      vi.mocked(readFile).mockResolvedValue(JSON.stringify({ version: mockTscVersion }));
+    });
+
+    it("returns version", async () => {
+      const { getTypeScriptUserAgentPair } = await import("./getTypeScriptUserAgentPair");
+      await expect(getTypeScriptUserAgentPair()).resolves.toEqual(["md/tsc", mockTscVersion]);
+    });
+
+    it("returns cached version on subsequent calls", async () => {
+      const { getTypeScriptUserAgentPair } = await import("./getTypeScriptUserAgentPair");
+
+      await expect(getTypeScriptUserAgentPair()).resolves.toEqual(["md/tsc", mockTscVersion]);
+      await expect(getTypeScriptUserAgentPair()).resolves.toEqual(["md/tsc", mockTscVersion]);
+
+      expect(readFile).toHaveBeenCalledTimes(1);
+    });
+
+    it("returns cached version on subsequent calls even if it's an empty string", async () => {
+      vi.mocked(readFile).mockResolvedValue(JSON.stringify({ version: "" }));
+
+      const { getTypeScriptUserAgentPair } = await import("./getTypeScriptUserAgentPair");
+      await expect(getTypeScriptUserAgentPair()).resolves.toEqual(["md/tsc", ""]);
+      await expect(getTypeScriptUserAgentPair()).resolves.toEqual(["md/tsc", ""]);
+
+      expect(readFile).toHaveBeenCalledTimes(1);
+    });
+
+    it("returns cached version on subsequent calls if version is not defined", async () => {
+      vi.mocked(readFile).mockResolvedValue(JSON.stringify({ name: "blah" }));
+
+      const { getTypeScriptUserAgentPair } = await import("./getTypeScriptUserAgentPair");
+      await expect(getTypeScriptUserAgentPair()).resolves.toBeUndefined();
+      await expect(getTypeScriptUserAgentPair()).resolves.toBeUndefined();
+
+      expect(readFile).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("when reading typescript/package.json throws error", () => {
+    beforeEach(() => {
+      vi.mocked(readFile).mockRejectedValue(new Error("File not found"));
+    });
+
+    it("returns undefined when typescript package.json read fails", async () => {
+      const { getTypeScriptUserAgentPair } = await import("./getTypeScriptUserAgentPair");
+      await expect(getTypeScriptUserAgentPair()).resolves.toBeUndefined();
+    });
+
+    it("returns undefined on subsequent calls after read failure", async () => {
+      const { getTypeScriptUserAgentPair } = await import("./getTypeScriptUserAgentPair");
+
+      await expect(getTypeScriptUserAgentPair()).resolves.toBeUndefined();
+      await expect(getTypeScriptUserAgentPair()).resolves.toBeUndefined();
+
+      expect(readFile).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("when typescript/package.json is not a valid JSON", () => {
+    beforeEach(() => {
+      vi.mocked(readFile).mockResolvedValue("Not a JSON");
+    });
+
+    it("returns undefined when typescript package.json parse fails", async () => {
+      const { getTypeScriptUserAgentPair } = await import("./getTypeScriptUserAgentPair");
+      await expect(getTypeScriptUserAgentPair()).resolves.toBeUndefined();
+    });
+
+    it("returns undefined on subsequent calls after parse failure", async () => {
+      const { getTypeScriptUserAgentPair } = await import("./getTypeScriptUserAgentPair");
+
+      await expect(getTypeScriptUserAgentPair()).resolves.toBeUndefined();
+      await expect(getTypeScriptUserAgentPair()).resolves.toBeUndefined();
+
+      expect(readFile).toHaveBeenCalledTimes(1);
+    });
+  });
+});

packages-internal/util-user-agent-node/src/getTypeScriptUserAgentPair.ts

@@ -0,0 +1,33 @@
+import type { UserAgentPair } from "@smithy/types";
+import { readFile } from "node:fs/promises";
+
+import { getTypeScriptPackageJsonPath } from "./getTypeScriptPackageJsonPath";
+
+let tscVersion: string | null | undefined;
+
+/**
+ * Returns the tyescript name and version as a user agent pair, if present.
+ * @internal
+ */
+export const getTypeScriptUserAgentPair = async (): Promise<UserAgentPair | undefined> => {
+  // If tscVersion is set from previous calls.
+  if (tscVersion === null) {
+    return undefined;
+  } else if (typeof tscVersion === "string") {
+    return ["md/tsc", tscVersion];
+  }
+
+  try {
+    const packageJson = await readFile(getTypeScriptPackageJsonPath(__dirname), "utf-8");
+    const { version } = JSON.parse(packageJson);
+    if (typeof version !== "string") {
+      tscVersion = null;
+      return undefined;
+    }
+    tscVersion = version;
+    return ["md/tsc", tscVersion];
+  } catch {
+    // Ignore error in case of failure in file read or JSON parsing.
+    tscVersion = null;
+  }
+};