pob 29.8.0 → 30.0.0

package/lib/generators/monorepo/PobMonorepoGenerator.js

@@ -1,31 +1,16 @@
 import { execSync } from "node:child_process";
 import fs from "node:fs";
 import { platform } from "node:process";
-import { getPluginConfiguration } from "@yarnpkg/cli";
-import { Configuration, Project } from "@yarnpkg/core";
-import { ppath } from "@yarnpkg/fslib";
+import Generator from "yeoman-generator";
+import * as packageUtils from "../../utils/package.js";
 import {
   buildDependenciesMaps,
   buildTopologicalOrderBatches,
+  discoverWorkspaces,
   getWorkspaceName,
-} from "yarn-workspace-utils";
-import Generator from "yeoman-generator";
-import * as packageUtils from "../../utils/package.js";
+} from "../../utils/workspaceUtils.js";
 import { copyAndFormatTpl } from "../../utils/writeAndFormat.js";
 
-export const createYarnProject = async () => {
-  const portablePath = ppath.cwd();
-
-  const configuration = await Configuration.find(
-    portablePath,
-    // eslint-disable-next-line unicorn/no-array-method-this-argument -- not an array
-    getPluginConfiguration(),
-  );
-  // eslint-disable-next-line unicorn/no-array-method-this-argument -- not an array
-  const { project } = await Project.find(configuration, portablePath);
-  return project;
-};
-
 const getAppTypes = (configs) => {
   const appConfigs = configs.filter(
     (config) => config && config.project && config.project.type === "app",
@@ -60,6 +45,17 @@ const hasBuild = (packages, configs) =>
       ),
   );
 
+const hasData = (packages, configs) =>
+  configs.some(
+    (config, index) =>
+      !!(
+        config &&
+        config.project &&
+        config.project.type === "app" &&
+        config.app.type === "alp-node"
+      ),
+  );
+
 const hasTamagui = (packages, configs) =>
   packages.some(
     (pkg) =>
@@ -118,10 +114,10 @@ export default class PobMonorepoGenerator extends Generator {
   }
 
   async initializing() {
-    const yarnProject = await createYarnProject(this.destinationPath());
+    const workspaces = await discoverWorkspaces(this.destinationPath());
     const batches = buildTopologicalOrderBatches(
-      yarnProject,
-      buildDependenciesMaps(yarnProject),
+      workspaces,
+      buildDependenciesMaps(workspaces),
     );
 
     this.packages = [];
@@ -134,7 +130,7 @@ export default class PobMonorepoGenerator extends Generator {
       );
 
       batch.forEach((workspace) => {
-        if (workspace === yarnProject.topLevelWorkspace) {
+        if (workspace.isRoot) {
           return;
         }
         this.packages.push(workspace.manifest.raw);
@@ -180,6 +176,13 @@ export default class PobMonorepoGenerator extends Generator {
         when: (answers) => answers.ci,
         default: config ? config.testing : true,
       },
+      {
+        type: "confirm",
+        name: "e2eTesting",
+        message: "Would you like e2e testing ?",
+        when: (answers) => answers.ci,
+        default: config ? config.e2eTesting : true,
+      },
       {
         type: "confirm",
         name: "codecov",
@@ -229,8 +232,6 @@ export default class PobMonorepoGenerator extends Generator {
 
     this.composeWith("pob:common:husky", {});
 
-    const isYarnVersionEnabled = this.pobLernaConfig.ci;
-
     const splitCIJobs = this.packageNames.length > 8;
 
     this.composeWith("pob:common:testing", {
@@ -238,8 +239,6 @@ export default class PobMonorepoGenerator extends Generator {
       enable: this.pobLernaConfig.testing,
       runner: this.pobLernaConfig.testRunner || "jest",
       disableYarnGitCache: this.options.disableYarnGitCache,
-      enableReleasePlease: false,
-      enableYarnVersion: isYarnVersionEnabled,
       testing: this.pobLernaConfig.testing,
       e2eTesting: this.pobLernaConfig.e2eTesting,
       build: this.pobLernaConfig.typescript === true,
@@ -253,6 +252,13 @@ export default class PobMonorepoGenerator extends Generator {
       splitCIJobs,
     });
 
+    const rootIgnorePaths = [
+      this.pobLernaConfig.e2eTesting &&
+        `${this.pobLernaConfig.e2eTesting === "." || this.pobLernaConfig.e2eTesting === true ? "" : `/${this.pobLernaConfig.e2eTesting}`}/playwright-report/`,
+      this.pobLernaConfig.e2eTesting &&
+        `${this.pobLernaConfig.e2eTesting === "." || this.pobLernaConfig.e2eTesting === true ? "" : `/${this.pobLernaConfig.e2eTesting}`}/test-results/`,
+    ].filter(Boolean);
+
     const gitignorePaths = [
       hasTamagui(this.packages, this.packageConfigs) && ".tamagui",
     ].filter(Boolean);
@@ -260,6 +266,7 @@ export default class PobMonorepoGenerator extends Generator {
     this.composeWith("pob:common:format-lint", {
       monorepo: true,
       documentation: this.pobLernaConfig.documentation,
+      storybook: pkg?.devDependencies?.storybook,
       typescript: this.pobLernaConfig.typescript,
       build: this.pobLernaConfig.typescript === true,
       testing: this.pobLernaConfig.testing,
@@ -271,10 +278,11 @@ export default class PobMonorepoGenerator extends Generator {
         ...gitignorePaths.map((path) => `/${path}`),
         hasDist(this.packages, this.packageConfigs) && "/dist",
         hasBuild(this.packages, this.packageConfigs) && "/build",
+        hasData(this.packages, this.packageConfigs) && "/data",
       ]
         .filter(Boolean)
         .join("\n"),
-      rootIgnorePaths: [],
+      rootIgnorePaths: rootIgnorePaths.join("\n"),
     });
 
     this.composeWith("pob:lib:doc", {
@@ -304,7 +312,11 @@ export default class PobMonorepoGenerator extends Generator {
       documentation: this.pobLernaConfig.documentation,
       testing: this.pobLernaConfig.testing,
       // TODO add workspaces paths like we do in format-lint
-      paths: gitignorePaths.join("\n"),
+      paths: [
+        // TODO remove gitignorePaths
+        ...gitignorePaths,
+        ...rootIgnorePaths,
+      ].join("\n"),
       // todo: fix this using workspaces
       // buildDirectory: this.pobLernaConfig.typescript ? `/*/build` : "",
     });
@@ -317,7 +329,6 @@ export default class PobMonorepoGenerator extends Generator {
       enablePublish: !this.options.isAppProject,
       withBabel: this.pobLernaConfig.typescript,
       isMonorepo: true,
-      enableYarnVersion: isYarnVersionEnabled,
       ci: this.pobLernaConfig.ci,
       disableYarnGitCache: this.options.disableYarnGitCache,
       updateOnly: this.options.updateOnly,

package/lib/generators/monorepo/lerna/MonorepoLernaGenerator.js

@@ -100,9 +100,6 @@ export default class MonorepoLernaGenerator extends Generator {
     packageUtils.removeDependencies(pkg, ["lerna"]);
     packageUtils.removeDevDependencies(pkg, ["lerna"]);
 
-    // TODO remove lerna completely
-    const isYarnVersionEnabled = true;
-
     const getPackagePobConfig = (config) => ({
       babelEnvs: [],
       ...(config && config.pob),
@@ -130,35 +127,25 @@ export default class MonorepoLernaGenerator extends Generator {
       lernaConfig.command.publish.ignoreChanges.push("**/tsconfig.json");
     }
 
-    if (isYarnVersionEnabled) {
-      if (pkg.version === "0.0.0" && lernaConfig && lernaConfig.version) {
-        if (lernaConfig.version === "independent") {
-          delete pkg.version;
-        } else {
-          pkg.version = lernaConfig.version;
-        }
+    if (pkg.version === "0.0.0" && lernaConfig && lernaConfig.version) {
+      if (lernaConfig.version === "independent") {
+        delete pkg.version;
+      } else {
+        pkg.version = lernaConfig.version;
       }
-      this.fs.delete(this.destinationPath("lerna.json"));
-    } else {
-      writeAndFormatJson(
-        this.fs,
-        this.destinationPath("lerna.json"),
-        lernaConfig,
-      );
     }
+    this.fs.delete(this.destinationPath("lerna.json"));
 
     if (this.fs.exists(this.destinationPath("lerna-debug.log"))) {
       this.fs.delete(this.destinationPath("lerna-debug.log"));
     }
 
-    packageUtils.addOrRemoveScripts(
-      pkg,
-      this.options.packageManager === "yarn" && !isYarnVersionEnabled,
-      {
-        version:
-          "YARN_ENABLE_IMMUTABLE_INSTALLS=false yarn && git add yarn.lock",
-      },
-    );
+    if (
+      pkg.scripts?.version ===
+      "YARN_ENABLE_IMMUTABLE_INSTALLS=false yarn && git add yarn.lock"
+    ) {
+      delete pkg.scripts.version;
+    }
 
     this.fs.writeJSON(this.destinationPath("package.json"), pkg);
   }

package/lib/generators/monorepo/workspaces/MonorepoWorkspacesGenerator.js

@@ -81,8 +81,6 @@ export default class MonorepoWorkspacesGenerator extends Generator {
       delete pkg.engines.yarn;
     }
 
-    const isYarnVersionEnabled = true;
-
     if (pkg.name !== "pob-monorepo") {
       packageUtils.addDevDependencies(pkg, ["repository-check-dirty"]);
     }
@@ -111,14 +109,12 @@ export default class MonorepoWorkspacesGenerator extends Generator {
             : "npm run lint:eslint --workspaces",
     });
 
-    packageUtils.addOrRemoveScripts(
-      pkg,
-      this.options.packageManager === "yarn" && !isYarnVersionEnabled,
-      {
-        version:
-          "YARN_ENABLE_IMMUTABLE_INSTALLS=false yarn && git add yarn.lock",
-      },
-    );
+    if (
+      pkg.scripts?.version ===
+      "YARN_ENABLE_IMMUTABLE_INSTALLS=false yarn && git add yarn.lock"
+    ) {
+      delete pkg.scripts.version;
+    }
 
     if (this.options.isAppProject) {
       packageUtils.addOrRemoveScripts(pkg, withBundler, {

package/lib/generators/pob/PobBaseGenerator.js

@@ -291,7 +291,7 @@ export default class PobBaseGenerator extends Generator {
 
   end() {
     if (this.isMonorepo && !this.options.updateOnly) {
-      console.log("To create a new lerna package: ");
+      console.log("To create a new monorepo package: ");
       console.log(" pob add <packageName>");
     }
   }

package/lib/utils/packageDependencyDescriptorUtils.js

@@ -0,0 +1,52 @@
+// TODO use pm-utils when available
+
+export const PackageDescriptorNameUtils = {
+  parse: (value) => {
+    if (value.startsWith("@")) {
+      const [scope, name] = value.slice(1).split("/", 2);
+      return { scope, name };
+    }
+    return { name: value };
+  },
+  stringify: (descriptor) => {
+    return descriptor.scope === undefined
+      ? descriptor.name
+      : `@${descriptor.scope}/${descriptor.name}`;
+  },
+};
+
+export const PackageDependencyDescriptorUtils = {
+  make: (descriptor, selector) => {
+    return {
+      key: descriptor.key,
+      npmName: descriptor.npmName,
+      nameDescriptor: descriptor.nameDescriptor,
+      selector,
+    };
+  },
+  parse: (dependencyKey, dependencyValue) => {
+    const parseFromNpm = (v) => {
+      if (!v.startsWith("@")) return v.split("@", 2);
+      const [packageNameWithoutFirstChar, selector] = v.slice(1).split("@", 2);
+      return [`@${packageNameWithoutFirstChar}`, selector];
+    };
+    const [name, selector] = dependencyValue.startsWith("npm:")
+      ? parseFromNpm(dependencyValue.slice("npm:".length))
+      : [dependencyKey, dependencyValue];
+
+    return {
+      key: dependencyKey,
+      npmName: name,
+      nameDescriptor: PackageDescriptorNameUtils.parse(name),
+      selector,
+    };
+  },
+  stringify: (descriptor) => {
+    return [
+      descriptor.key,
+      descriptor.npmName !== descriptor.key
+        ? `npm:${descriptor.npmName}@${descriptor.selector}`
+        : descriptor.selector,
+    ];
+  },
+};

package/lib/utils/packageDependencyDescriptorUtils.ts.backup

@@ -0,0 +1,79 @@
+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);
+        return { scope, name };
+      }
+      return { name: value };
+    },
+    stringify: (descriptor) => {
+      return descriptor.scope === undefined
+        ? descriptor.name
+        : `@${descriptor.scope}/${descriptor.name}`;
+    },
+  };
+
+export interface PackageDependencyDescriptor {
+  key: string;
+  npmName: string;
+  nameDescriptor: 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,
+        npmName: descriptor.npmName,
+        nameDescriptor: descriptor.nameDescriptor,
+        selector,
+      };
+    },
+    parse: (dependencyKey, dependencyValue) => {
+      const [name, selector] = dependencyValue.startsWith("npm:")
+        ? (() => {
+            const v = dependencyValue.slice("npm:".length);
+            if (!v.startsWith("@")) return v.split("@", 2);
+            const [packageNameWithoutFirstChar, selector] = v
+              .slice(1)
+              .split("@", 2);
+            return [`@${packageNameWithoutFirstChar}`, selector];
+          })()
+        : [dependencyKey, dependencyValue];
+
+      return {
+        key: dependencyKey,
+        npmName: name,
+        nameDescriptor: PackageDescriptorNameUtils.parse(name),
+        selector,
+      };
+    },
+    stringify: (descriptor) => {
+      return [
+        descriptor.key,
+        descriptor.npmName !== descriptor.key
+          ? `npm:${descriptor.npmName}@${descriptor.selector}`
+          : descriptor.selector,
+      ];
+    },
+  };

package/lib/utils/workspaceUtils.js

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+// eslint-disable-next-line n/no-unsupported-features/node-builtins
+import { glob } from "node:fs/promises";
+import path from "node:path";
+import { PackageDependencyDescriptorUtils } from "./packageDependencyDescriptorUtils.js";
+
+export const getWorkspaceName = (workspace) => {
+  if (workspace?.manifest?.raw?.name) return workspace.manifest.raw.name;
+  return path.basename(workspace.location) || "unnamed-workspace";
+};
+
+export const discoverWorkspaces = async (rootPath) => {
+  const rootPackageJSONPath = path.join(rootPath, "package.json");
+  const rootPkg = JSON.parse(fs.readFileSync(rootPackageJSONPath));
+
+  let workspaceGlobs = [];
+  if (Array.isArray(rootPkg.workspaces)) {
+    workspaceGlobs = rootPkg.workspaces;
+  } else if (typeof rootPkg.workspaces === "object") {
+    workspaceGlobs = (rootPkg.workspaces && rootPkg.workspaces.packages) || [];
+  }
+
+  const workspaces = [
+    {
+      name: rootPkg.name,
+      location: ".",
+      manifest: { raw: rootPkg },
+      relativeCwd: { toString: () => "." },
+      isRoot: true,
+    },
+  ];
+
+  const patternPackageJsons = workspaceGlobs.map((g) =>
+    path.join(g, "package.json"),
+  );
+  const found = new Set();
+  for (const pattern of patternPackageJsons) {
+    for await (const match of glob(pattern, { cwd: rootPath, nodir: true })) {
+      if (found.has(match)) continue;
+      found.add(match);
+      const filePath = path.join(rootPath, match);
+      const content = JSON.parse(fs.readFileSync(filePath));
+      const dir = path.dirname(match);
+      workspaces.push({
+        name: content.name,
+        location: dir || ".",
+        manifest: { raw: content },
+        relativeCwd: { toString: () => dir || "." },
+      });
+    }
+  }
+
+  return workspaces;
+};
+
+export const buildDependenciesMaps = (workspaces) => {
+  const dependenciesMap = new Map();
+
+  const workspacesByName = new Map(
+    workspaces.filter((w) => !!w.name).map((w) => [w.name, w]),
+  );
+  const dependencyTypes = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+  ];
+
+  for (const dependent of workspaces) {
+    for (const set of dependencyTypes) {
+      const deps =
+        (dependent.manifest.raw && dependent.manifest.raw[set]) || {};
+      for (const [dependencyKey, dependencyValue] of Object.entries(deps)) {
+        if (!dependencyValue) continue;
+        const descriptor = PackageDependencyDescriptorUtils.parse(
+          dependencyKey,
+          String(dependencyValue),
+        );
+        const workspace = workspacesByName.get(descriptor.npmName);
+        if (!workspace) continue;
+
+        const entries = dependenciesMap.get(dependent) || [];
+        entries.push([workspace, set, descriptor]);
+        dependenciesMap.set(dependent, entries);
+      }
+    }
+  }
+
+  return dependenciesMap;
+};
+
+export const buildTopologicalOrderBatches = (workspaces, dependenciesMap) => {
+  const batches = [];
+  const added = new Set();
+  const toAdd = new Set(workspaces);
+
+  while (toAdd.size > 0) {
+    const batch = new Set();
+    for (const workspace of toAdd) {
+      if (workspace.isRoot && 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;
+};
+
+export const buildDependentsMaps = (workspaces) => {
+  const dependentsMap = new Map();
+  const dependenciesMap = buildDependenciesMaps(workspaces);
+  for (const [dependent, relations] of dependenciesMap) {
+    for (const [workspace, set, descriptor] of relations) {
+      const cmd = dependentsMap.get(workspace) || [];
+      cmd.push([dependent, set, descriptor]);
+      dependentsMap.set(workspace, cmd);
+    }
+  }
+  return dependentsMap;
+};

package/lib/utils/workspaceUtils.test.js

@@ -0,0 +1,134 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  buildDependenciesMaps,
+  buildTopologicalOrderBatches,
+  discoverWorkspaces,
+} from "./workspaceUtils.js";
+
+async function prepareMonorepo(tmpDir) {
+  await fs.mkdir(path.join(tmpDir, "packages"), { recursive: true });
+  const rootPkg = {
+    name: "root",
+    workspaces: ["packages/*"],
+  };
+  await fs.writeFile(
+    path.join(tmpDir, "package.json"),
+    JSON.stringify(rootPkg, null, 2),
+  );
+
+  // package c
+  const cDir = path.join(tmpDir, "packages/c");
+  await fs.mkdir(cDir, { recursive: true });
+  await fs.writeFile(
+    path.join(cDir, "package.json"),
+    JSON.stringify({ name: "@ex/c" }, null, 2),
+  );
+
+  // package b depends on c
+  const bDir = path.join(tmpDir, "packages/b");
+  await fs.mkdir(bDir, { recursive: true });
+  await fs.writeFile(
+    path.join(bDir, "package.json"),
+    JSON.stringify(
+      { name: "@ex/b", dependencies: { "@ex/c": "1.0.0" } },
+      null,
+      2,
+    ),
+  );
+
+  // package a depends on b
+  const aDir = path.join(tmpDir, "packages/a");
+  await fs.mkdir(aDir, { recursive: true });
+  await fs.writeFile(
+    path.join(aDir, "package.json"),
+    JSON.stringify(
+      { name: "@ex/a", dependencies: { "@ex/b": "1.0.0" } },
+      null,
+      2,
+    ),
+  );
+
+  return tmpDir;
+}
+
+describe("workspaceUtils", () => {
+  it("should discover workspaces", async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "pob-"));
+    await prepareMonorepo(tmp);
+    const workspaces = await discoverWorkspaces(tmp);
+    // root + a + b + c
+    expect(workspaces.length).toBeGreaterThanOrEqual(4);
+    const names = workspaces.map((w) => w.name).toSorted();
+    expect(names).toEqual(["@ex/a", "@ex/b", "@ex/c", "root"].toSorted());
+  });
+
+  it("should build dependencies maps and topological batches", async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "pob-"));
+    await prepareMonorepo(tmp);
+    const workspaces = await discoverWorkspaces(tmp);
+    const dependenciesMap = buildDependenciesMaps(workspaces);
+    // find workspace by name
+    const byName = new Map(workspaces.map((w) => [w.name, w]));
+    const a = byName.get("@ex/a");
+    const b = byName.get("@ex/b");
+    // const c = byName.get("@ex/c");
+    expect(dependenciesMap.get(a)).toBeDefined();
+    expect(dependenciesMap.get(b)).toBeDefined();
+    // topological batches
+    const batches = buildTopologicalOrderBatches(workspaces, dependenciesMap);
+    // flatten names excluding root
+    const nonRoot = batches
+      .flat()
+      .filter((w) => !w.isRoot)
+      .map((w) => w.name);
+    // c should come before b which comes before a
+    expect(nonRoot.indexOf("@ex/c")).toBeLessThan(nonRoot.indexOf("@ex/b"));
+    expect(nonRoot.indexOf("@ex/b")).toBeLessThan(nonRoot.indexOf("@ex/a"));
+  });
+
+  it("throws on circular dependency", async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "pob-"));
+    await fs.mkdir(path.join(tmp, "packages"), { recursive: true });
+    const rootPkg = {
+      name: "root",
+      workspaces: ["packages/*"],
+    };
+    await fs.writeFile(
+      path.join(tmp, "package.json"),
+      JSON.stringify(rootPkg, null, 2),
+    );
+
+    // package x depends on y
+    const xDir = path.join(tmp, "packages/x");
+    await fs.mkdir(xDir, { recursive: true });
+    await fs.writeFile(
+      path.join(xDir, "package.json"),
+      JSON.stringify(
+        { name: "@ex/x", dependencies: { "@ex/y": "1.0.0" } },
+        null,
+        2,
+      ),
+    );
+
+    // package y depends on x
+    const yDir = path.join(tmp, "packages/y");
+    await fs.mkdir(yDir, { recursive: true });
+    await fs.writeFile(
+      path.join(yDir, "package.json"),
+      JSON.stringify(
+        { name: "@ex/y", dependencies: { "@ex/x": "1.0.0" } },
+        null,
+        2,
+      ),
+    );
+
+    const workspaces = await discoverWorkspaces(tmp);
+    const dependenciesMap = buildDependenciesMaps(workspaces);
+    expect(() =>
+      buildTopologicalOrderBatches(workspaces, dependenciesMap),
+    ).toThrow();
+  });
+});