Read workspace scripts from package.json files

Author: miorel

workspaces/repository-scripts/src/main.ts

@@ -1,5 +1,7 @@
 import process from "node:process";
 
+import { chdirToCurrentGitRepositoryRoot } from "@code-chronicles/util/chdirToCurrentGitRepositoryRoot";
+
 import { runCommands } from "./runCommands.ts";
 import { SCRIPTS, isScript } from "./scripts.ts";
 
@@ -16,6 +18,8 @@ async function main() {
     throw new Error(`Invalid script: ${script}`);
   }
 
+  await chdirToCurrentGitRepositoryRoot();
+
   const action = async () => await runCommands(script, scriptArgs);
   const actionWrapper = SCRIPTS[script]?.run;
 

workspaces/repository-scripts/src/runCommands.ts

@@ -1,19 +1,18 @@
 import type { SpawnOptions } from "node:child_process";
 import process from "node:process";
 
-import { getCurrentGitRepositoryRoot } from "@code-chronicles/util/getCurrentGitRepositoryRoot";
+import nullthrows from "nullthrows";
+import { z } from "zod";
+
 import { maybeThrow } from "@code-chronicles/util/maybeThrow";
 import { promiseAllLimitingConcurrency } from "@code-chronicles/util/promiseAllLimitingConcurrency";
+import { readPackageJson } from "@code-chronicles/util/readPackageJson";
 import { readWorkspaces } from "@code-chronicles/util/readWorkspaces";
 import { runWithLogGroupAsync } from "@code-chronicles/util/runWithLogGroupAsync";
 import { spawnWithSafeStdio } from "@code-chronicles/util/spawnWithSafeStdio";
 import { stripPrefixOrThrow } from "@code-chronicles/util/stripPrefixOrThrow";
 
-import {
-  SCRIPTS,
-  SCRIPTS_TO_SKIP_BY_WORKSPACE,
-  type Script,
-} from "./scripts.ts";
+import { SCRIPTS, type Script } from "./scripts.ts";
 
 type FailedCommand = {
   command: string;
@@ -44,41 +43,41 @@ export async function runCommands(
     }
   };
 
-  const commands = [
-    async () => {
+  const commands = (await readWorkspaces()).map((workspace) => async () => {
+    if (workspace.location === ".") {
       const rootCommand = SCRIPTS[script]?.repositoryRootCommand;
-      if (rootCommand != null) {
-        const currentGitRepositoryRoot = await getCurrentGitRepositoryRoot();
-
-        await runWithLogGroupAsync(
-          `Running script ${script} for repository root!`,
-          async () =>
-            await run.apply(null, [
-              ...rootCommand,
-              { cwd: currentGitRepositoryRoot },
-            ]),
-        );
-      }
-    },
-
-    ...(await readWorkspaces()).map((workspace) => async () => {
-      const workspaceShortName = stripPrefixOrThrow(
-        workspace,
-        "@code-chronicles/",
-      );
-      if (SCRIPTS_TO_SKIP_BY_WORKSPACE[workspaceShortName]?.has(script)) {
-        console.error(
-          `Skipping script ${script} for workspace: ${workspaceShortName}`,
-        );
+      if (rootCommand == null) {
+        console.error(`Skipping script ${script} for repository root!`);
         return;
       }
 
       await runWithLogGroupAsync(
-        `Running script ${script} for workspace: ${workspaceShortName}`,
-        async () => await run("yarn", ["workspace", workspace, script]),
+        `Running script ${script} for repository root!`,
+        async () => await run(...rootCommand),
+      );
+      return;
+    }
+
+    const workspaceName = nullthrows(workspace.name);
+    const workspaceShortName = stripPrefixOrThrow(
+      workspaceName,
+      "@code-chronicles/",
+    );
+
+    const { scripts } = await readPackageJson(workspace.location);
+
+    if (scripts?.[script] == null) {
+      console.error(
+        `Skipping script ${script} for workspace: ${workspaceShortName}`,
       );
-    }),
-  ];
+      return;
+    }
+
+    await runWithLogGroupAsync(
+      `Running script ${script} for workspace: ${workspaceShortName}`,
+      async () => await run("yarn", ["workspace", workspaceName, script]),
+    );
+  });
 
   await promiseAllLimitingConcurrency(
     commands,

workspaces/repository-scripts/src/scripts.ts

@@ -63,18 +63,3 @@ export type Script = keyof typeof SCRIPTS;
 export function isScript(value: string): value is Script {
   return Object.hasOwn(SCRIPTS, value);
 }
-
-// TODO: maybe read this from the package.json of each workspace
-export const SCRIPTS_TO_SKIP_BY_WORKSPACE: Readonly<
-  Record<string, ReadonlySet<Script>>
-> = {
-  "download-leetcode-submissions": new Set(["test"]),
-  "eslint-config": new Set(["test", "typecheck"]),
-  "fetch-leetcode-problem-list": new Set(["test"]),
-  "fetch-recent-accepted-leetcode-submissions": new Set(["test"]),
-  "generate-health-report": new Set(["test"]),
-  "javascript-leetcode-month": new Set(["test"]),
-  "leetcode-zen-mode": new Set(["test"]),
-  "post-leetcode-potd-to-discord": new Set(["test"]),
-  "repository-scripts": new Set(["test"]),
-};

workspaces/util/src/chdirToCurrentGitRepositoryRoot.ts

@@ -0,0 +1,7 @@
+import process from "node:process";
+
+import { getCurrentGitRepositoryRoot } from "@code-chronicles/util/getCurrentGitRepositoryRoot";
+
+export async function chdirToCurrentGitRepositoryRoot(): Promise<void> {
+  process.chdir(await getCurrentGitRepositoryRoot());
+}

workspaces/util/src/readPackageJson.ts

@@ -0,0 +1,19 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+import { z } from "zod";
+
+const packageJsonZodType = z.object({
+  scripts: z.record(z.string(), z.string()).optional(),
+});
+
+export type PackageJson = z.infer<typeof packageJsonZodType>;
+
+export async function readPackageJson(
+  directory: string = ".",
+): Promise<PackageJson> {
+  const text = await readFile(path.join(directory, "package.json"), {
+    encoding: "utf8",
+  });
+  return packageJsonZodType.passthrough().parse(JSON.parse(text));
+}

workspaces/util/src/readWorkspaces.ts

@@ -1,19 +1,30 @@
-import { assertIsObject } from "@code-chronicles/util/assertIsObject";
-import { assertIsString } from "@code-chronicles/util/assertIsString";
+import { z } from "zod";
+
 import { compareStringsCaseInsensitive } from "@code-chronicles/util/compareStringsCaseInsensitive";
 import { getLines } from "@code-chronicles/util/getLines";
 import { execWithArgsOrThrowOnNzec } from "@code-chronicles/util/execWithArgsOrThrowOnNzec";
 
-export async function readWorkspaces(): Promise<string[]> {
+const workspaceZodType = z.union([
+  z.object({
+    location: z.string(),
+    name: z.string(),
+  }),
+  z.object({
+    location: z.literal("."),
+    name: z.null(),
+  }),
+]);
+
+export type Workspace = z.infer<typeof workspaceZodType>;
+
+export async function readWorkspaces(): Promise<Workspace[]> {
   const yarnCommandResult = await execWithArgsOrThrowOnNzec("yarn", [
     "workspaces",
     "list",
     "--json",
   ]);
 
   return [...getLines(yarnCommandResult.stdout)]
-    .map((line) => assertIsObject(JSON.parse(line)))
-    .filter((workspace) => workspace.location !== ".")
-    .map(({ name }) => assertIsString(name))
-    .sort(compareStringsCaseInsensitive);
+    .map((line) => workspaceZodType.parse(JSON.parse(line)))
+    .sort((a, b) => compareStringsCaseInsensitive(a.name ?? "", b.name ?? ""));
 }

yarn.config.cjs

@@ -1,5 +1,7 @@
 const { defineConfig } = require("@yarnpkg/types");
 
+const NAME_PREFIX = "@code-chronicles/";
+
 module.exports = defineConfig({
   async constraints({ Yarn }) {
     const rootWorkspace = Yarn.workspace({ cwd: "." });
@@ -8,6 +10,20 @@ module.exports = defineConfig({
       return;
     }
 
+    // Expect each workspace to specify a name, except for the root.
+    for (const workspace of Yarn.workspaces()) {
+      if (workspace.cwd === ".") {
+        workspace.unset("name");
+      } else {
+        const { name } = workspace.manifest;
+        if (typeof name !== "string" || !name.startsWith(NAME_PREFIX)) {
+          workspace.error(
+            `Repository name didn't start with the prefix ${JSON.stringify(NAME_PREFIX)}`,
+          );
+        }
+      }
+    }
+
     // Use ESM everywhere.
     for (const workspace of Yarn.workspaces()) {
       workspace.set("type", "module");
@@ -40,10 +56,10 @@ module.exports = defineConfig({
 
     // Expect each workspace to specify a version, except for the root.
     for (const workspace of Yarn.workspaces()) {
-      if (workspace.cwd !== ".") {
-        workspace.set("version", workspace.manifest.version ?? "0.0.1");
-      } else {
+      if (workspace.cwd === ".") {
         workspace.unset("version");
+      } else {
+        workspace.set("version", workspace.manifest.version ?? "0.0.1");
       }
     }