@storm-software/workspace-tools 1.270.2 → 1.271.0

package/src/utils/lock-file.ts

@@ -1,159 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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);
-  }
-};