@pob/version 5.1.0 → 6.0.0

package/src/utils/mapWorkspaces.test.ts

@@ -0,0 +1,89 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createProjectWorkspace, createWorkspace } from "./packageUtils.ts";
+
+const toAbs = (p: string) => path.resolve(p);
+
+const fixturesRoot = path.resolve(
+  new URL("../../__fixtures__", import.meta.url).pathname,
+);
+
+describe("mapWorkspaces - baseline checks", () => {
+  it("should map packages for array workspaces (yarn-monorepo)", async () => {
+    const root = path.join(fixturesRoot, "yarn-monorepo");
+
+    const rootWorkspace = await createWorkspace(root);
+    const project = await createProjectWorkspace(rootWorkspace);
+    const keys = [...project.children.keys()].toSorted();
+
+    expect(keys.length).toBe(5);
+    expect(keys).toContain("package-1");
+    expect(keys).toContain("package-2");
+    expect(project.children.get("package-1")!.cwd).toBe(
+      toAbs(path.join(root, "packages/package-1")),
+    );
+  });
+
+  it("should map packages for object workspaces (monorepo-object-form)", async () => {
+    const root = path.join(fixturesRoot, "yarn-monorepo-object-form");
+    const rootWorkspace = await createWorkspace(root);
+    const project = await createProjectWorkspace(rootWorkspace);
+    const keys = [...project.children.keys()].toSorted();
+    expect(keys.length).toBe(5);
+  });
+
+  it("should map nested patterns and double star patterns", async () => {
+    const root = path.join(fixturesRoot, "yarn-monorepo-nested");
+    const rootWorkspace = await createWorkspace(root);
+    const project = await createProjectWorkspace(rootWorkspace);
+    const keys = [...project.children.keys()];
+    expect(keys).toContain("nested-package-1");
+    expect(keys).toContain("nested-package-2");
+    expect(keys).toContain("deep-nested-package");
+  });
+
+  it("should fallback to folder name when package.json has no name", async () => {
+    const root = path.join(fixturesRoot, "yarn-monorepo-no-name");
+    const rootWorkspace = await createWorkspace(root);
+    const project = await createProjectWorkspace(rootWorkspace);
+    const keys = [...project.children.keys()];
+    expect(keys).toContain("no-name-package");
+  });
+
+  it("should throw when duplicate workspace names exist (baseline behavior)", async () => {
+    const root = path.join(fixturesRoot, "yarn-monorepo-duplicate-names");
+    const rootWorkspace = await createWorkspace(root);
+    let thrown = false;
+    try {
+      await createProjectWorkspace(rootWorkspace);
+    } catch {
+      thrown = true;
+    }
+    expect(thrown).toBe(true);
+  });
+
+  it("should expose an error or skip invalid package.json (baseline behavior)", async () => {
+    const root = path.join(fixturesRoot, "yarn-monorepo-invalid-package-json");
+    const rootWorkspace = await createWorkspace(root);
+    // Ensure it throws or skips: we'll try to call createProjectWorkspace and assert throw
+    let thrown = false;
+    try {
+      await createProjectWorkspace(rootWorkspace);
+    } catch {
+      thrown = true;
+    }
+    // Accept either behavior as baseline: ensure we detect if it currently throws.
+    // We assert that at least it doesn't silently include the invalid package by name
+    // so if it didn't throw, ensure the invalid package isn't listed
+    if (!thrown) {
+      const project = await createProjectWorkspace(rootWorkspace);
+      const keys = [...project.children.keys()];
+      expect(keys).not.toContain("invalid-json-package");
+    }
+  });
+
+  it("should have node:fs/promises glob available (engine requirement)", async () => {
+    const fsp = await import("node:fs/promises");
+    expect(typeof (fsp as any).glob).toBe("function");
+  });
+});

package/src/utils/packageDependenciesUtils.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { PackageDependencyDescriptorUtils } from "./packageDependenciesUtils.ts";
+
+describe("PackageDependencyDescriptorUtils.parse", () => {
+  it.each([
+    [
+      ["name", "1.1.1"],
+      { key: "name", name: { name: "name" }, selector: "1.1.1" },
+    ],
+    [
+      ["name2", "npm:@scope/name@1.1.1"],
+      {
+        key: "name2",
+        name: { scope: "scope", name: "name" },
+        selector: "1.1.1",
+      },
+    ],
+  ] as const)('should parse "%s" to "%s"', ([k, v], expected) => {
+    expect(PackageDependencyDescriptorUtils.parse(k, v)).toStrictEqual(
+      expected,
+    );
+  });
+});
+
+// describe(stringifyPackageDescriptor.name, () => {});

package/src/utils/packageDependenciesUtils.ts

@@ -0,0 +1,80 @@
+/**
+ * Combination of an optional scope and name.
+ *
+ * eg `@npm/types`
+ */
+export interface PackageDescriptorName {
+  scope?: string;
+  name: string;
+}
+
+interface DescriptorUtils<Descriptor> {
+  parse: (value: string) => Descriptor;
+  stringify: (descriptor: Descriptor) => string;
+}
+
+export const PackageDescriptorNameUtils: DescriptorUtils<PackageDescriptorName> =
+  {
+    parse: (value) => {
+      if (value.startsWith("@")) {
+        const [scope, name] = value.slice(1).split("/", 2);
+        if (!scope || !name) {
+          throw new Error(`Invalid package descriptor name: ${value}`);
+        }
+        return { scope, name };
+      }
+      return { name: value };
+    },
+    stringify: (descriptor) => {
+      return descriptor.scope === undefined
+        ? descriptor.name
+        : `@${descriptor.scope}/${descriptor.name}`;
+    },
+  };
+
+export interface PackageDependencyDescriptor {
+  key: string;
+  name: PackageDescriptorName;
+  selector: string; // can be npm tag or version or version range or git url or local folder path
+}
+
+interface PackageDependencyDescriptorUtils<
+  Descriptor = PackageDependencyDescriptor,
+> {
+  make: (descriptor: Descriptor, selector: string) => Descriptor;
+  parse: (dependencyKey: string, dependencyValue: string) => Descriptor;
+  stringify: (descriptor: Descriptor) => [key: string, value: string];
+}
+
+export const PackageDependencyDescriptorUtils: PackageDependencyDescriptorUtils =
+  {
+    make: (descriptor, selector) => {
+      return { key: descriptor.key, name: descriptor.name, selector };
+    },
+    parse: (dependencyKey, dependencyValue) => {
+      const [name, selector] = dependencyValue.startsWith("npm:")
+        ? (() => {
+            const v = dependencyValue.slice("npm:".length);
+            if (!v.startsWith("@")) return v.split("@", 2) as [string, string];
+            const [packageNameWithoutFirstChar, selector] = v
+              .slice(1)
+              .split("@", 2);
+            if (!packageNameWithoutFirstChar || !selector) {
+              throw new Error(`Invalid package descriptor: ${dependencyValue}`);
+            }
+            return [`@${packageNameWithoutFirstChar}`, selector];
+          })()
+        : [dependencyKey, dependencyValue];
+
+      return {
+        key: dependencyKey,
+        name: PackageDescriptorNameUtils.parse(name),
+        selector,
+      };
+    },
+    stringify: (descriptor) => {
+      return [descriptor.key, descriptor.selector];
+    },
+  };
+
+// export const PackageDependencySelectorUtils;

package/src/utils/packageUtils.test.ts

@@ -0,0 +1,32 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  createProjectWorkspace,
+  createWorkspace,
+  findRootWorkspace,
+} from "./packageUtils.ts";
+
+const fixturesRoot = path.resolve(
+  new URL("../../__fixtures__", import.meta.url).pathname,
+);
+
+describe("packageUtils integration", () => {
+  it("findRootWorkspace finds root from subpackage path", async () => {
+    const subPath = path.join(fixturesRoot, "yarn-monorepo/packages/package-1");
+    const root = await findRootWorkspace(subPath);
+    expect(root).toBeTruthy();
+    expect(root!.pkg.name).toBe("yarn-monorepo");
+  });
+
+  it("createProjectWorkspace returns children and correct relativeCwd", async () => {
+    const rootPath = path.join(fixturesRoot, "yarn-monorepo");
+    const rootWorkspace = await createWorkspace(rootPath);
+    const project = await createProjectWorkspace(rootWorkspace);
+    const children = [...project.children.values()];
+    expect(children.length).toBe(5);
+    // Check a sample relativeCwd
+    const pkg1 = project.children.get("package-1");
+    expect(pkg1).toBeTruthy();
+    expect(pkg1!.relativeCwd).toBe("packages/package-1");
+  });
+});

package/src/utils/packageUtils.ts

@@ -0,0 +1,129 @@
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import fs, { glob } from "node:fs/promises";
+import path from "node:path";
+import type { PackageJson } from "type-fest";
+
+export interface Workspace {
+  readonly cwd: string;
+  readonly relativeCwd?: string;
+  readonly pkg: PackageJson;
+}
+
+export interface ProjectWorkspace {
+  readonly root: Workspace;
+  readonly children: Map<string, Workspace>;
+}
+
+async function mapWorkspacesFromPkg({
+  cwd,
+  pkg,
+}: {
+  cwd: string;
+  pkg: PackageJson;
+}): Promise<Map<string, Workspace>> {
+  const workspacesPatterns: string[] = Array.isArray(pkg.workspaces)
+    ? pkg.workspaces
+    : pkg.workspaces?.packages || [];
+
+  const map = new Map<string, Workspace>();
+
+  for (const pattern of workspacesPatterns) {
+    const normalized = pattern.endsWith("package.json")
+      ? pattern
+      : `${pattern.replace(/\/*$/, "")}/package.json`;
+
+    const files = glob(normalized, { cwd });
+    for await (const file of files) {
+      const packageDir = path.join(cwd, path.dirname(file));
+      const packageJson: PackageJson = await readPkg(packageDir);
+      const workspaceName = packageJson.name || path.basename(packageDir);
+      if (map.has(workspaceName)) {
+        const existingWorkspace = map.get(workspaceName);
+        if (existingWorkspace && existingWorkspace.cwd !== packageDir) {
+          throw new Error(
+            `must not have multiple workspaces with the same name\npackage '${workspaceName}' has conflicts in the following paths:\n    ${existingWorkspace.cwd}\n    ${packageDir}`,
+          );
+        }
+        // if it's the same package dir, ignore duplicate match
+        if (existingWorkspace?.cwd === packageDir) continue;
+      }
+      map.set(workspaceName, { cwd: packageDir, pkg: packageJson });
+    }
+  }
+  return map;
+}
+
+export const createProjectWorkspace = async (
+  root: Workspace,
+): Promise<ProjectWorkspace> => {
+  const map: Map<string, Workspace> = root.pkg.workspaces
+    ? await mapWorkspacesFromPkg({ cwd: root.cwd, pkg: root.pkg })
+    : new Map();
+
+  const children = new Map<string, Workspace>(
+    [...map.entries()].map(([packageName, workspace]) => {
+      const w: Workspace = {
+        ...workspace,
+        relativeCwd: path.relative(root.cwd, workspace.cwd),
+      };
+      return [packageName, w] as const;
+    }),
+  );
+  return { root, children };
+};
+
+const isAccessible = (path: string): Promise<boolean> =>
+  fs.access(path).then(
+    () => true,
+    () => false,
+  );
+
+export const findRootWorkspace = async (
+  cwd: string,
+): Promise<Workspace | null> => {
+  let currentPath = cwd;
+  do {
+    const isRootIfOneOfThesePathsExists = await Promise.all([
+      isAccessible(path.join(currentPath, ".yarnrc.yml")),
+      isAccessible(path.join(currentPath, "yarn.lock")),
+      isAccessible(path.join(currentPath, "bun.lock")),
+      isAccessible(path.join(currentPath, "pnpm-lock.yaml")),
+    ]);
+    if (isRootIfOneOfThesePathsExists.some(Boolean)) {
+      return createWorkspace(currentPath);
+    }
+    currentPath = path.dirname(currentPath);
+  } while (currentPath && currentPath !== "/");
+  return null;
+};
+
+const getPackageJsonPath = (cwd: string): string =>
+  path.join(cwd, "package.json");
+
+export const createWorkspace = async (path: string): Promise<Workspace> => {
+  const pkg = await readPkg(path);
+  return { cwd: path, pkg };
+};
+
+export async function writePkg(workspace: Workspace): Promise<void> {
+  const string = `${JSON.stringify(workspace.pkg, null, 2)}\n`;
+  await fs.writeFile(getPackageJsonPath(workspace.cwd), string, "utf8");
+}
+
+export async function readPkg(cwd: string): Promise<PackageJson> {
+  const packagePath = getPackageJsonPath(cwd);
+  // eslint-disable-next-line @typescript-eslint/use-unknown-in-catch-callback-variable
+  const pkg = await fs.readFile(packagePath, "utf8").catch((error: Error) => {
+    throw new Error(
+      `Failed to read "${packagePath}": ${error instanceof Error ? error.message : String(error)}`,
+    );
+  });
+  try {
+    return JSON.parse(pkg);
+  } catch (error: unknown) {
+    throw new Error(
+      `Failed to parse "${packagePath}": ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
+    );
+  }
+}

package/src/utils/updateChangelog.ts

@@ -0,0 +1,39 @@
+import fs from "node:fs/promises";
+
+const COMMIT_GUIDELINE =
+  "See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.";
+
+const CHANGELOG_HEADER = [
+  "# Changelog",
+  "",
+  "All notable changes to this project will be documented in this file.",
+  COMMIT_GUIDELINE,
+  "",
+].join("\n");
+
+export const updateChangelogFile = async (
+  versionChangelogContent: string,
+  tagPrefix: string,
+  file = "CHANGELOG.md",
+): Promise<void> => {
+  const START_OF_LAST_RELEASE_PATTERN = new RegExp(
+    `(^#+ \\[?(?:${tagPrefix})?\\d+\\.\\d+\\.\\d+|<a name=)`,
+    "m",
+  );
+
+  let oldContent = "";
+
+  try {
+    oldContent = await fs.readFile(file, "utf8");
+    const oldContentStart = oldContent.search(START_OF_LAST_RELEASE_PATTERN);
+    // find the position of the last release and remove header:
+    if (oldContentStart !== -1) {
+      oldContent = oldContent.slice(Math.max(0, oldContentStart));
+    }
+  } catch {}
+
+  await fs.writeFile(
+    file,
+    `${CHANGELOG_HEADER}\n${versionChangelogContent}\n${oldContent}`,
+  );
+};

package/src/utils/workspaceUtils.ts

@@ -0,0 +1,142 @@
+/* eslint-disable complexity */
+import path from "node:path";
+import { getMapArrayItemForKey } from "./mapUtils.ts";
+import type { PackageDependencyDescriptor } from "./packageDependenciesUtils.ts";
+import {
+  PackageDependencyDescriptorUtils,
+  PackageDescriptorNameUtils,
+} from "./packageDependenciesUtils.ts";
+import type { ProjectWorkspace, Workspace } from "./packageUtils.ts";
+
+const allDependenciesTypes = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+] as const;
+export type DependencyType = (typeof allDependenciesTypes)[number];
+
+export const getWorkspaceName = (workspace: Workspace): string => {
+  return (
+    workspace.pkg.name ?? (path.basename(workspace.cwd) || "unnamed-workspace")
+  );
+};
+
+type WorkspacesDependenciesMap = Map<
+  Workspace,
+  [Workspace, DependencyType, PackageDependencyDescriptor][]
+>;
+
+export const buildDependentsMaps = (
+  project: ProjectWorkspace,
+): WorkspacesDependenciesMap => {
+  const dependentsMap: WorkspacesDependenciesMap = new Map<
+    Workspace,
+    [Workspace, DependencyType, PackageDependencyDescriptor][]
+  >();
+
+  // Note that we need to do this before applying the new versions,
+  // otherwise the `findWorkspacesByDescriptor` calls won't be able to
+  // resolve the workspaces anymore (because the workspace versions will
+  // have changed and won't match the outdated dependencies).
+
+  for (const [, dependent] of project.children) {
+    for (const set of allDependenciesTypes) {
+      for (const [dependencyKey, dependencyValue] of Object.entries(
+        dependent.pkg[set] || {},
+      )) {
+        if (!dependencyValue) continue;
+        const descriptor = PackageDependencyDescriptorUtils.parse(
+          dependencyKey,
+          dependencyValue,
+        );
+        const workspace = project.children.get(
+          PackageDescriptorNameUtils.stringify(descriptor.name),
+        );
+        if (!workspace) continue;
+
+        const dependents = getMapArrayItemForKey(dependentsMap, workspace);
+        dependents.push([dependent, set, descriptor]);
+      }
+    }
+  }
+
+  return dependentsMap;
+};
+
+export const buildDependenciesMaps = (
+  project: ProjectWorkspace,
+): WorkspacesDependenciesMap => {
+  const dependenciesMap: WorkspacesDependenciesMap = new Map<
+    Workspace,
+    [Workspace, DependencyType, PackageDependencyDescriptor][]
+  >();
+
+  // Note that we need to do this before applying the new versions,
+  // otherwise the `findWorkspacesByDescriptor` calls won't be able to
+  // resolve the workspaces anymore (because the workspace versions will
+  // have changed and won't match the outdated dependencies).
+
+  for (const dependent of project.children.values()) {
+    for (const set of allDependenciesTypes) {
+      for (const [dependencyKey, dependencyValue] of Object.entries(
+        dependent.pkg[set] || {},
+      )) {
+        if (!dependencyValue) continue;
+        const descriptor = PackageDependencyDescriptorUtils.parse(
+          dependencyKey,
+          dependencyValue,
+        );
+
+        const workspace = project.children.get(
+          PackageDescriptorNameUtils.stringify(descriptor.name),
+        );
+        if (!workspace) continue;
+
+        const dependencies = getMapArrayItemForKey(dependenciesMap, dependent);
+        dependencies.push([workspace, set, descriptor]);
+      }
+    }
+  }
+
+  return dependenciesMap;
+};
+
+export const buildTopologicalOrderBatches = (
+  project: ProjectWorkspace,
+  dependenciesMap: WorkspacesDependenciesMap,
+): Workspace[][] => {
+  const batches: Workspace[][] = [];
+
+  const added = new Set<Workspace>();
+  const toAdd = new Set<Workspace>([
+    project.root,
+    ...project.children.values(),
+  ]);
+
+  while (toAdd.size > 0) {
+    const batch = new Set<Workspace>();
+    for (const workspace of toAdd) {
+      // make sure top level workspace is always in the last batch
+      if (workspace === project.root && toAdd.size > 1) {
+        continue;
+      }
+
+      const dependencies = dependenciesMap.get(workspace);
+      if (!dependencies || dependencies.every((w) => added.has(w[0]))) {
+        batch.add(workspace);
+      }
+    }
+
+    for (const workspace of batch) {
+      added.add(workspace);
+      toAdd.delete(workspace);
+    }
+
+    if (batch.size === 0) {
+      throw new Error("Circular dependency detected");
+    }
+    batches.push([...batch]);
+  }
+
+  return batches;
+};

package/.editorconfig

@@ -1,13 +0,0 @@
-# EditorConfig helps developers define and maintain consistent
-# coding styles between different editors and IDEs
-# http://editorconfig.org
-
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true

package/.eslintrc.json

@@ -1,4 +0,0 @@
-{
-  "root": true,
-  "extends": ["@pob/eslint-config", "@pob/eslint-config-node"]
-}

package/CHANGELOG.md

@@ -1,108 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-# [5.1.0](https://github.com/christophehurpeau/pob/compare/@pob/version@5.0.1...@pob/version@5.1.0) (2020-02-02)
-
-
-### Features
-
-* update eslint configs ([2add77e](https://github.com/christophehurpeau/pob/commit/2add77e6fa5d81065cec87007ae54b22921de3c5))
-
-
-
-
-
-## [5.0.1](https://github.com/christophehurpeau/pob/compare/@pob/version@5.0.0...@pob/version@5.0.1) (2019-12-29)
-
-**Note:** Version bump only for package @pob/version
-
-
-
-
-
-# [5.0.0](https://github.com/christophehurpeau/pob/compare/@pob/version@4.33.4...@pob/version@5.0.0) (2019-12-13)
-
-
-### Features
-
-* add nullish-coalescing-operator and optional-chaining ([fca6e0b](https://github.com/christophehurpeau/pob/commit/fca6e0b6ddfd5b5851134fa0cdbb1eb56930c8d4))
-
-
-### BREAKING CHANGES
-
-* drop node 8
-
-
-
-
-
-## [4.33.4](https://github.com/christophehurpeau/pob/compare/@pob/version@4.33.3...@pob/version@4.33.4) (2019-09-14)
-
-**Note:** Version bump only for package @pob/version
-
-
-
-
-
-## [4.33.3](https://github.com/christophehurpeau/pob/compare/@pob/version@4.33.2...@pob/version@4.33.3) (2019-09-13)
-
-**Note:** Version bump only for package @pob/version
-
-
-
-
-
-## [4.33.2](https://github.com/christophehurpeau/pob/compare/@pob/version@4.33.0...@pob/version@4.33.2) (2019-09-13)
-
-
-### Bug Fixes
-
-* self update ([02173ba](https://github.com/christophehurpeau/pob/commit/02173ba))
-
-
-
-
-
-## [4.33.1](https://github.com/christophehurpeau/pob/compare/@pob/version@4.33.0...@pob/version@4.33.1) (2019-08-30)
-
-
-### Bug Fixes
-
-* self update ([02173ba](https://github.com/christophehurpeau/pob/commit/02173ba))
-
-
-
-
-
-# [4.33.0](https://github.com/christophehurpeau/pob/compare/@pob/version@4.32.1...@pob/version@4.33.0) (2019-08-29)
-
-
-### Bug Fixes
-
-* fix @pob/version package.json import ([e457914](https://github.com/christophehurpeau/pob/commit/e457914))
-
-
-### Features
-
-* workspaces for scoped packages ([c85fd52](https://github.com/christophehurpeau/pob/commit/c85fd52))
-
-
-
-
-
-## [4.32.1](https://github.com/christophehurpeau/pob/compare/@pob/version@4.32.0...@pob/version@4.32.1) (2019-07-12)
-
-**Note:** Version bump only for package @pob/version
-
-
-
-
-
-# 4.32.0 (2019-07-12)
-
-
-### Features
-
-* add @pob/version for future use ([3b74e5b](https://github.com/christophehurpeau/pob/commit/3b74e5b))

package/generate-index.js

@@ -1,13 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-
-fs.writeFileSync(
-  require.resolve('./lib/index.js'),
-  `'use strict';
-
-const pkg = require('../package.json');
-
-module.exports = { version: pkg.version, date: ${Date.now()} };
-`
-);

package/lib/index.d.ts

@@ -1,8 +0,0 @@
-interface Version {
-  version: string;
-  date: number;
-}
-
-declare const version: Version;
-
-export = version;