@storm-software/workspace-tools 1.269.0 → 1.270.0

package/src/utils/lock-file.ts

@@ -0,0 +1,159 @@
+import {
+  output,
+  readJsonFile,
+  workspaceRoot,
+  type CreateDependenciesContext,
+  type CreateNodesContext,
+  type PackageManager,
+  type ProjectGraphExternalNode,
+  type RawProjectGraphDependency,
+} from "@nx/devkit";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import {
+  getNpmLockfileDependencies,
+  getNpmLockfileNodes,
+} from "nx/src/plugins/js/lock-file/npm-parser";
+import {
+  getPnpmLockfileDependencies,
+  getPnpmLockfileNodes,
+} from "nx/src/plugins/js/lock-file/pnpm-parser";
+import {
+  getYarnLockfileDependencies,
+  getYarnLockfileNodes,
+} from "nx/src/plugins/js/lock-file/yarn-parser";
+
+export const YARN_LOCK_FILE = "yarn.lock";
+export const NPM_LOCK_FILE = "package-lock.json";
+export const PNPM_LOCK_FILE = "pnpm-lock.yaml";
+export const LOCK_FILES = [YARN_LOCK_FILE, NPM_LOCK_FILE, PNPM_LOCK_FILE];
+
+export const YARN_LOCK_PATH = join(workspaceRoot, YARN_LOCK_FILE);
+export const NPM_LOCK_PATH = join(workspaceRoot, NPM_LOCK_FILE);
+export const PNPM_LOCK_PATH = join(workspaceRoot, PNPM_LOCK_FILE);
+
+/**
+ * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ */
+export function getLockFileNodes(
+  packageManager: PackageManager,
+  contents: string,
+  lockFileHash: string,
+  context: CreateNodesContext,
+): Record<string, ProjectGraphExternalNode> {
+  try {
+    if (packageManager === "yarn") {
+      const packageJson = readJsonFile(
+        join(context.workspaceRoot, "package.json"),
+      );
+      return getYarnLockfileNodes(contents, lockFileHash, packageJson);
+    }
+    if (packageManager === "pnpm") {
+      return getPnpmLockfileNodes(contents, lockFileHash);
+    }
+    if (packageManager === "npm") {
+      return getNpmLockfileNodes(contents, lockFileHash);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e),
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+
+/**
+ * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ */
+export function getLockFileDependencies(
+  packageManager: PackageManager,
+  contents: string,
+  lockFileHash: string,
+  context: CreateDependenciesContext,
+): RawProjectGraphDependency[] {
+  try {
+    if (packageManager === "yarn") {
+      return getYarnLockfileDependencies(contents, lockFileHash, context);
+    }
+    if (packageManager === "pnpm") {
+      return getPnpmLockfileDependencies(contents, lockFileHash, context);
+    }
+    if (packageManager === "npm") {
+      return getNpmLockfileDependencies(contents, lockFileHash, context);
+    }
+  } catch (e) {
+    if (!isPostInstallProcess()) {
+      output.error({
+        title: `Failed to parse ${packageManager} lockfile`,
+        bodyLines: errorBodyLines(e),
+      });
+    }
+    throw e;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+
+export function lockFileExists(packageManager: PackageManager): boolean {
+  if (packageManager === "yarn") {
+    return existsSync(YARN_LOCK_PATH);
+  }
+  if (packageManager === "pnpm") {
+    return existsSync(PNPM_LOCK_PATH);
+  }
+  if (packageManager === "npm") {
+    return existsSync(NPM_LOCK_PATH);
+  }
+  throw new Error(
+    `Unknown package manager ${packageManager} or lock file missing`,
+  );
+}
+
+/**
+ * Returns lock file name based on the detected package manager in the root
+ * @param packageManager
+ * @returns
+ */
+export function getLockFileName(packageManager: PackageManager): string {
+  if (packageManager === "yarn") {
+    return YARN_LOCK_FILE;
+  }
+  if (packageManager === "pnpm") {
+    return PNPM_LOCK_FILE;
+  }
+  if (packageManager === "npm") {
+    return NPM_LOCK_FILE;
+  }
+  throw new Error(`Unknown package manager: ${packageManager}`);
+}
+
+// generate body lines for error message
+function errorBodyLines(
+  originalError: Error,
+  additionalInfo: string[] = [],
+): string[] {
+  const result = [
+    "Please open an issue at `https://github.com/storm-software/storm-ops/issues/new?template=1-bug.yml` and provide a reproduction.",
+    ...(additionalInfo as string[]),
+  ];
+
+  if (originalError.message) {
+    result.push(`\nOriginal error: ${originalError.message}\n\n`);
+  }
+
+  if (originalError.stack) {
+    result.push(originalError.stack);
+  }
+
+  return result;
+}
+
+function isPostInstallProcess(): boolean {
+  return (
+    process.env.npm_command === "install" &&
+    process.env.npm_lifecycle_event === "postinstall"
+  );
+}

package/src/utils/package-helpers.ts

@@ -0,0 +1,54 @@
+import {
+  joinPathFragments,
+  ProjectConfiguration,
+  readJsonFile,
+} from "@nx/devkit";
+import { existsSync } from "node:fs";
+import type { PackageJson } from "nx/src/utils/package-json.js";
+import { isEqualProjectTag, ProjectTagConstants } from "./project-tags";
+import { CargoToml, parseCargoToml } from "./toml";
+
+export type PackageManagerType = "package.json" | "Cargo.toml";
+export const PackageManagerTypes = {
+  PackageJson: "package.json" as PackageManagerType,
+  CargoToml: "Cargo.toml" as PackageManagerType,
+};
+
+export type PackageInfo = {
+  content: PackageJson | CargoToml;
+  type: PackageManagerType;
+};
+
+export const getPackageInfo = (
+  project: ProjectConfiguration,
+): null | PackageInfo => {
+  if (
+    isEqualProjectTag(
+      project,
+      ProjectTagConstants.Language.TAG_ID,
+      ProjectTagConstants.Language.RUST,
+    ) &&
+    existsSync(joinPathFragments(project.root, "Cargo.toml"))
+  ) {
+    return {
+      type: "Cargo.toml",
+      content: parseCargoToml(joinPathFragments(project.root, "Cargo.toml")),
+    };
+  } else if (
+    isEqualProjectTag(
+      project,
+      ProjectTagConstants.Language.TAG_ID,
+      ProjectTagConstants.Language.TYPESCRIPT,
+    ) &&
+    existsSync(joinPathFragments(project.root, "package.json"))
+  ) {
+    return {
+      type: "package.json",
+      content: readJsonFile(
+        joinPathFragments(project.root, "package.json"),
+      ) as PackageJson,
+    };
+  }
+
+  return null;
+};

package/src/utils/plugin-helpers.ts

@@ -0,0 +1,112 @@
+import { ProjectConfiguration, readJsonFile } from "@nx/devkit";
+import defu from "defu";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { PackageJson } from "pkg-types";
+import { getProjectTag, ProjectTagConstants } from "./project-tags";
+
+export const getProjectPlatform = (
+  project: ProjectConfiguration,
+  ignoreTags = false,
+): "node" | "neutral" | "browser" | "worker" => {
+  const tsconfigJson = readJsonFile(join(project.root, "tsconfig.json"));
+  if (!tsconfigJson) {
+    throw new Error(`No tsconfig.json found in project root: ${project.root}`);
+  }
+
+  const packageJson = readJsonFile(join(project.root, "package.json"));
+  if (!packageJson) {
+    throw new Error(`No package.json found in project root: ${project.root}`);
+  }
+
+  let platformTag: string | undefined = undefined;
+  if (!ignoreTags) {
+    platformTag = getProjectTag(project, ProjectTagConstants.Platform.TAG_ID);
+  }
+
+  if (platformTag !== ProjectTagConstants.Platform.NEUTRAL) {
+    const types = Array.isArray(tsconfigJson.compilerOptions?.types)
+      ? tsconfigJson.compilerOptions.types
+      : [];
+
+    if (
+      platformTag === ProjectTagConstants.Platform.WORKER ||
+      types.some(
+        (type) => type.toLowerCase() === "@cloudflare/workers-types",
+      ) ||
+      packageJson.devDependencies?.["@cloudflare/workers-types"] ||
+      packageJson.devDependencies?.["wrangler"]
+    ) {
+      return "worker";
+    }
+
+    if (
+      platformTag === ProjectTagConstants.Platform.NODE ||
+      types?.some((type) => type.toLowerCase() === "node") ||
+      packageJson.devDependencies?.["@types/node"]
+    ) {
+      return "node";
+    }
+
+    if (
+      platformTag === ProjectTagConstants.Platform.BROWSER ||
+      types?.some((type) => type.toLowerCase() === "dom") ||
+      (packageJson.dependencies &&
+        Object.keys(packageJson.dependencies).some((dependency) =>
+          dependency.includes("react"),
+        )) ||
+      (packageJson.devDependencies &&
+        Object.keys(packageJson.devDependencies).some((devDependency) =>
+          devDependency.includes("react"),
+        ))
+    ) {
+      return "browser";
+    }
+  }
+
+  return "neutral";
+};
+
+export const getProjectConfigFromProjectJsonPath = (
+  projectJsonPath: string,
+  packageJson: PackageJson,
+): ProjectConfiguration => {
+  return getProjectConfigFromProjectRoot(dirname(projectJsonPath), packageJson);
+};
+
+export const getProjectConfigFromProjectRoot = (
+  projectRoot: string,
+  packageJson: PackageJson,
+): ProjectConfiguration => {
+  const { nx, name } = packageJson;
+  const projectJson = readJsonFile(join(projectRoot, "project.json"));
+
+  return defu(nx ?? {}, projectJson, {
+    targets: {},
+    tags: [],
+    name,
+    root: projectRoot,
+  }) as ProjectConfiguration;
+};
+
+export const getProjectRoot = (
+  configPath: string,
+  workspaceRoot: string,
+): string | null => {
+  try {
+    const root = dirname(configPath);
+    const projectRoot = join(workspaceRoot, root);
+
+    if (
+      !existsSync(join(projectRoot, "package.json")) &&
+      !existsSync(join(projectRoot, "project.json"))
+    ) {
+      return null;
+    }
+
+    return projectRoot;
+  } catch (error_) {
+    console.error(error_);
+    return null;
+  }
+};

package/src/utils/pnpm-deps-update.ts

@@ -0,0 +1,111 @@
+import { joinPaths } from "@storm-software/config-tools";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { format } from "prettier";
+import readYamlFile from "read-yaml-file";
+
+let pnpmCatalog!: Record<string, string>;
+
+/**
+ * Update package.json dependencies to use pnpm catalog versions
+ *
+ * @param packageRoot - The root of the package
+ * @param workspaceRoot - The root of the workspace
+ */
+export async function pnpmCatalogUpdate(
+  packageRoot: string,
+  workspaceRoot: string = process.cwd(),
+) {
+  if (!pnpmCatalog) {
+    const pnpmWorkspacePath = joinPaths(workspaceRoot, "pnpm-workspace.yaml");
+    if (!existsSync(pnpmWorkspacePath)) {
+      console.warn(
+        `No \`pnpm-workspace.yaml\` file found in workspace root (searching in: ${pnpmWorkspacePath}). Skipping pnpm catalog read for now.`,
+      );
+
+      return;
+    }
+
+    const pnpmWorkspaceYaml = await readYamlFile<{
+      catalog: Record<string, string>;
+    }>(pnpmWorkspacePath);
+    console.info(
+      `pnpmWorkspaceYaml: ${JSON.stringify(pnpmWorkspaceYaml ?? {})}`,
+    );
+
+    if (pnpmWorkspaceYaml?.catalog) {
+      pnpmCatalog = pnpmWorkspaceYaml.catalog;
+    } else {
+      console.warn(
+        `Found a \`pnpm-workspace.yaml\` file in the workspace root directory, but no pnpm catalog existed:
+File name: ${pnpmWorkspacePath}
+File contents: ${pnpmWorkspaceYaml ? JSON.stringify(pnpmWorkspaceYaml) : "EMPTY FILE"}`,
+      );
+    }
+  }
+
+  if (!pnpmCatalog) {
+    console.warn(
+      `No pnpm catalog found. Attempting to read from workspace root's \`pnpm-workspace.yaml\` file.`,
+    );
+  }
+
+  const packageJsonPath = joinPaths(packageRoot, "package.json");
+  const packageJsonFile = await readFile(packageJsonPath, "utf8");
+  if (!packageJsonFile) {
+    throw new Error(
+      "No package.json file found in package root: " + packageRoot,
+    );
+  }
+
+  const packageJson = JSON.parse(packageJsonFile);
+  for (const dependencyType of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+  ]) {
+    const dependencies = packageJson[dependencyType];
+    if (!dependencies) {
+      continue;
+    }
+
+    for (const dependencyName of Object.keys(dependencies)) {
+      if (dependencies[dependencyName] === "catalog:") {
+        if (!pnpmCatalog) {
+          throw new Error(
+            `Dependency ${dependencyName} is marked as \`catalog:\`, but no catalog exists in the workspace root's \`pnpm-workspace.yaml\` file.`,
+          );
+        }
+
+        const catalogVersion = pnpmCatalog[dependencyName];
+        if (!catalogVersion) {
+          throw new Error("Missing pnpm catalog version for " + dependencyName);
+        }
+
+        dependencies[dependencyName] = catalogVersion;
+      } else if (dependencies[dependencyName].startsWith("catalog:")) {
+        throw new Error("multiple named catalogs not supported");
+      }
+    }
+  }
+
+  return writeFile(
+    packageJsonPath,
+    await format(JSON.stringify(packageJson), {
+      parser: "json",
+      proseWrap: "always",
+      trailingComma: "none",
+      tabWidth: 2,
+      semi: true,
+      singleQuote: false,
+      quoteProps: "as-needed",
+      insertPragma: false,
+      bracketSameLine: true,
+      printWidth: 80,
+      bracketSpacing: true,
+      arrowParens: "avoid",
+      endOfLine: "lf",
+      plugins: ["prettier-plugin-pkg"],
+    }),
+  );
+}

package/src/utils/project-tags.ts

@@ -0,0 +1,162 @@
+import { ProjectConfiguration } from "@nx/devkit";
+import {
+  ProjectTagDistStyleValue,
+  ProjectTagLanguageValue,
+  ProjectTagPlatformValue,
+  ProjectTagRegistryValue,
+  ProjectTagTypeValue,
+  ProjectTagVariant,
+} from "../types";
+
+export const ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language" as ProjectTagVariant,
+
+    TYPESCRIPT: "typescript" as ProjectTagLanguageValue,
+    RUST: "rust" as ProjectTagLanguageValue,
+  },
+  ProjectType: {
+    TAG_ID: "type" as ProjectTagVariant,
+
+    LIBRARY: "library" as ProjectTagTypeValue,
+    APPLICATION: "application" as ProjectTagTypeValue,
+  },
+  DistStyle: {
+    TAG_ID: "dist-style" as ProjectTagVariant,
+
+    NORMAL: "normal" as ProjectTagDistStyleValue,
+    CLEAN: "clean" as ProjectTagDistStyleValue,
+  },
+  Provider: {
+    TAG_ID: "provider" as ProjectTagVariant,
+  },
+  Platform: {
+    TAG_ID: "platform" as ProjectTagVariant,
+
+    NODE: "node" as ProjectTagPlatformValue,
+    BROWSER: "browser" as ProjectTagPlatformValue,
+    NEUTRAL: "neutral" as ProjectTagPlatformValue,
+    WORKER: "worker" as ProjectTagPlatformValue,
+  },
+  Registry: {
+    TAG_ID: "registry" as ProjectTagVariant,
+
+    CARGO: "cargo" as ProjectTagRegistryValue,
+    NPM: "npm" as ProjectTagRegistryValue,
+    CONTAINER: "container" as ProjectTagRegistryValue,
+    CYCLONE: "cyclone" as ProjectTagRegistryValue,
+  },
+  Plugin: {
+    TAG_ID: "plugin" as ProjectTagVariant,
+  },
+} as const;
+
+export const formatProjectTag = (variant: ProjectTagVariant, value: string) => {
+  return `${variant}:${value}`;
+};
+
+export const hasProjectTag = (
+  project: ProjectConfiguration,
+  variant: ProjectTagVariant,
+) => {
+  project.tags = project.tags ?? [];
+
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some(
+    (tag) => tag.startsWith(prefix) && tag.length > prefix.length,
+  );
+};
+
+export const getProjectTag = (
+  project: ProjectConfiguration,
+  variant: ProjectTagVariant,
+): string | undefined => {
+  if (!hasProjectTag(project, variant)) {
+    return undefined;
+  }
+
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag) => tag.startsWith(prefix));
+
+  return tag?.replace(prefix, "");
+};
+
+export const isEqualProjectTag = (
+  project: ProjectConfiguration,
+  variant: ProjectTagVariant,
+  value: string,
+): boolean => {
+  const tag = getProjectTag(project, variant);
+
+  return !!(tag && tag?.toUpperCase() === value.toUpperCase());
+};
+
+export const addProjectTag = (
+  project: ProjectConfiguration,
+  variant: ProjectTagVariant,
+  value: string,
+  options: {
+    overwrite?: boolean;
+  } = {
+    overwrite: false,
+  },
+) => {
+  project.tags = project.tags ?? [];
+  if (options.overwrite || !hasProjectTag(project, variant)) {
+    project.tags = project.tags.filter(
+      (tag) => !tag.startsWith(formatProjectTag(variant, "")),
+    );
+    project.tags.push(formatProjectTag(variant, value));
+  }
+};
+
+export const addPluginProjectTag = (
+  project: ProjectConfiguration,
+  plugin: string,
+) => {
+  project.tags = project.tags ?? [];
+  project.tags.push(
+    formatProjectTag(ProjectTagConstants.Plugin.TAG_ID, plugin),
+  );
+};
+
+export const setDefaultProjectTags = (
+  project: ProjectConfiguration,
+  plugin?: string,
+) => {
+  project.tags = project.tags ?? [];
+
+  addProjectTag(
+    project,
+    ProjectTagConstants.ProjectType.TAG_ID,
+    project.projectType === "application"
+      ? ProjectTagConstants.ProjectType.APPLICATION
+      : ProjectTagConstants.ProjectType.LIBRARY,
+    { overwrite: true },
+  );
+  addProjectTag(
+    project,
+    ProjectTagConstants.DistStyle.TAG_ID,
+    project.targets && Object.keys(project.targets).includes("clean-package")
+      ? ProjectTagConstants.DistStyle.CLEAN
+      : ProjectTagConstants.DistStyle.NORMAL,
+    { overwrite: true },
+  );
+  addProjectTag(
+    project,
+    ProjectTagConstants.Platform.TAG_ID,
+    project.targets?.build?.options.platform === "node"
+      ? ProjectTagConstants.Platform.NODE
+      : project.targets?.build?.options.platform === "worker"
+        ? ProjectTagConstants.Platform.WORKER
+        : project.targets?.build?.options.platform === "browser"
+          ? ProjectTagConstants.Platform.BROWSER
+          : ProjectTagConstants.Platform.NEUTRAL,
+    { overwrite: false },
+  );
+
+  if (plugin) {
+    addPluginProjectTag(project, plugin);
+  }
+};