@effect-x/envault 0.1.0

package/src/workspace.ts

@@ -0,0 +1,120 @@
+import { Effect, Schema } from "effect";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import type { WorkspaceInfo, WorkspaceKind } from "./domain.ts";
+import { EnvFileError } from "./env-file.ts";
+
+const readJson = (
+  target: string,
+): Effect.Effect<Record<string, unknown> | undefined, EnvFileError> =>
+  Effect.tryPromise({
+    try: async () => JSON.parse(await fs.readFile(target, "utf8")) as Record<string, unknown>,
+    catch: (cause) =>
+      new EnvFileError({ message: `Failed to read JSON ${target}: ${String(cause)}` }),
+  }).pipe(Effect.catch(() => Effect.succeed(undefined)));
+
+const exists = (target: string): Effect.Effect<boolean> =>
+  Effect.tryPromise({
+    try: async () => {
+      await fs.access(target);
+      return true;
+    },
+    catch: () => new EnvFileError({ message: `Path does not exist: ${target}` }),
+  }).pipe(Effect.catch(() => Effect.succeed(false)));
+
+const packageWorkspacePatterns = (
+  packageJson: Record<string, unknown> | undefined,
+): ReadonlyArray<string> => {
+  if (packageJson === undefined) return [];
+  const workspaces = packageJson["workspaces"];
+  if (Array.isArray(workspaces))
+    return workspaces.filter((value): value is string => typeof value === "string");
+  if (typeof workspaces === "object" && workspaces !== null && "packages" in workspaces) {
+    const packages = (workspaces as { readonly packages?: unknown | undefined }).packages;
+    return Array.isArray(packages)
+      ? packages.filter((value): value is string => typeof value === "string")
+      : [];
+  }
+  return [];
+};
+
+const readPnpmWorkspacePatterns = async (target: string): Promise<ReadonlyArray<string>> => {
+  const content = await fs.readFile(target, "utf8");
+  const patterns: Array<string> = [];
+  for (const line of content.split(/\r?\n/u)) {
+    const match = line.match(/^\s*-\s+(.+)\s*$/u);
+    if (match?.[1] !== undefined) {
+      patterns.push(match[1].replace(/^['"]|['"]$/gu, ""));
+    }
+  }
+  return patterns;
+};
+
+const expandSimplePattern = async (
+  root: string,
+  pattern: string,
+): Promise<ReadonlyArray<string>> => {
+  const starIndex = pattern.indexOf("*");
+  if (starIndex < 0) return [path.resolve(root, pattern)];
+
+  const base = pattern.slice(0, starIndex).replace(/\/$/u, "");
+  const basePath = path.resolve(root, base);
+  const entries = await fs.readdir(basePath, { withFileTypes: true }).catch(() => []);
+
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(basePath, entry.name));
+};
+
+const detectKind = ({
+  packagePatterns,
+  pnpmPatterns,
+  hasMoon,
+  hasNx,
+}: {
+  readonly packagePatterns: ReadonlyArray<string>;
+  readonly pnpmPatterns: ReadonlyArray<string>;
+  readonly hasMoon: boolean;
+  readonly hasNx: boolean;
+}): WorkspaceKind => {
+  if (hasMoon) return "moon";
+  if (hasNx) return "nx";
+  if (pnpmPatterns.length > 0) return "pnpm";
+  if (packagePatterns.length > 0) return "npm";
+  return "single";
+};
+
+export const detectWorkspace = (root: string): Effect.Effect<WorkspaceInfo, EnvFileError> =>
+  Effect.gen(function* () {
+    const absoluteRoot = path.resolve(root);
+    const packageJson = yield* readJson(path.join(absoluteRoot, "package.json"));
+    const packagePatterns = packageWorkspacePatterns(packageJson);
+    const pnpmWorkspacePath = path.join(absoluteRoot, "pnpm-workspace.yaml");
+    const pnpmPatterns = (yield* exists(pnpmWorkspacePath))
+      ? yield* Effect.tryPromise({
+          try: () => readPnpmWorkspacePatterns(pnpmWorkspacePath),
+          catch: (cause) =>
+            new EnvFileError({ message: `Failed to read pnpm-workspace.yaml: ${String(cause)}` }),
+        })
+      : [];
+    const hasMoon = yield* exists(path.join(absoluteRoot, ".moon", "workspace.yml"));
+    const hasNx = yield* exists(path.join(absoluteRoot, "nx.json"));
+    const patterns = pnpmPatterns.length > 0 ? pnpmPatterns : packagePatterns;
+    const expanded = yield* Effect.tryPromise({
+      try: async () =>
+        (
+          await Promise.all(patterns.map((pattern) => expandSimplePattern(absoluteRoot, pattern)))
+        ).flat(),
+      catch: (cause) =>
+        new EnvFileError({ message: `Failed to expand workspace patterns: ${String(cause)}` }),
+    });
+
+    return {
+      root: absoluteRoot,
+      kind: detectKind({ packagePatterns, pnpmPatterns, hasMoon, hasNx }),
+      packageDirectories: expanded.sort((left, right) => left.localeCompare(right)),
+    };
+  }).pipe(Effect.withSpan("workspace.detect"));
+
+export const encodeWorkspaceInfo = (workspace: WorkspaceInfo): unknown =>
+  Schema.encodeUnknownSync(Schema.Any)(workspace);