@beignet/cli 0.0.52 → 0.0.53

package/src/analysis/workspace.ts

@@ -1,4 +1,4 @@
-import { readdir, readFile, stat } from "node:fs/promises";
+import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
 import {
@@ -9,6 +9,7 @@ import {
   resolveConfig,
 } from "../config.js";
 import {
+  isAnalysisSourceFile,
   isAnalysisSourceFileExtension,
   sourceFileScriptKind,
 } from "./source-files.js";
@@ -22,8 +23,23 @@ const ignoredDirectoryNames = new Set([
   "node_modules",
 ]);
 
+export type AnalysisProject = {
+  targetDir: string;
+  canonicalDir: string;
+  prefix: string;
+  name?: string;
+  dependencies: Set<string>;
+  localDependencies: Set<string>;
+  config: ResolvedBeignetConfig;
+  files: string[];
+  compilerOptions: ts.CompilerOptions;
+  compilerConfigFiles: string[];
+  moduleResolutionCache: ts.ModuleResolutionCache;
+};
+
 export type AnalysisWorkspace = {
   targetDir: string;
+  projects: AnalysisProject[];
   files: string[];
   fileSet: Set<string>;
   config: ResolvedBeignetConfig;
@@ -44,24 +60,70 @@ export async function createAnalysisWorkspace(
 ): Promise<AnalysisWorkspace> {
   const targetDir = path.resolve(cwd);
   await assertDirectory(targetDir);
-  const files = await listProjectFiles(targetDir);
-  const fileSet = new Set(files);
+  const appFiles = await listProjectFiles(targetDir);
   const config = options.config
     ? resolveConfig(options.config)
-    : await loadBeignetConfig(targetDir, files);
-  const { compilerConfigFiles, compilerOptions } =
-    resolveCompilerConfiguration(targetDir);
-  const moduleResolutionCache = ts.createModuleResolutionCache(
-    targetDir,
-    ts.sys.useCaseSensitiveFileNames
-      ? (fileName) => fileName
-      : (fileName) => fileName.toLowerCase(),
-    compilerOptions,
-  );
+    : await loadBeignetConfig(targetDir, appFiles);
+  const app = await createProject(targetDir, targetDir, appFiles, config);
+  const projects = [app];
+  for (const directory of config.workspace.packages) {
+    const packageDir = path.resolve(targetDir, directory);
+    await assertDirectory(packageDir);
+    const canonical = await realpath(packageDir);
+    for (const project of projects) {
+      const existing = project.canonicalDir;
+      if (within(canonical, existing) || within(existing, canonical)) {
+        throw new Error(
+          `Workspace package ${directory} overlaps ${project.prefix || "the app"}. Package roots must be separate directories.`,
+        );
+      }
+    }
+    const packageFiles = await listProjectFiles(packageDir);
+    const packageConfig = await loadBeignetConfig(packageDir, packageFiles);
+    const project = await createProject(
+      targetDir,
+      packageDir,
+      packageFiles,
+      packageConfig,
+    );
+    if (!project.name)
+      throw new Error(
+        `Workspace package ${directory} must have a name in package.json.`,
+      );
+    if (projects.some((candidate) => candidate.name === project.name)) {
+      throw new Error(`Duplicate workspace package name ${project.name}.`);
+    }
+    projects.push(project);
+  }
+  const reachable = new Set([app]);
+  for (const project of reachable) {
+    for (const candidate of projects.slice(1)) {
+      if (candidate.name && project.dependencies.has(candidate.name))
+        reachable.add(candidate);
+    }
+  }
+  for (const project of projects.slice(1)) {
+    if (!reachable.has(project))
+      throw new Error(
+        `Workspace package ${project.name} is not a declared dependency of the app or its configured source packages.`,
+      );
+  }
+  const files = projects
+    .flatMap((project) =>
+      project.files.map((file) => projectPath(project, file)),
+    )
+    .sort();
+  const fileSet = new Set(files);
+  const { compilerOptions, moduleResolutionCache } = app;
+  const compilerConfigFiles = [
+    ...new Set(projects.flatMap((project) => project.compilerConfigFiles)),
+  ].sort();
   const sources = new Map<string, string>();
   const sourceFiles = new Map<string, ts.SourceFile>();
 
   const readSource = async (file: string): Promise<string> => {
+    if (!fileSet.has(file))
+      throw new Error(`Source file is outside the analysis workspace: ${file}`);
     const cached = sources.get(file);
     if (cached !== undefined) return cached;
 
@@ -72,6 +134,7 @@ export async function createAnalysisWorkspace(
 
   return {
     targetDir,
+    projects,
     files,
     fileSet,
     config,
@@ -136,7 +199,11 @@ export async function listProjectFiles(targetDir: string): Promise<string[]> {
 export function resolveLocalSourceFile(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
+    | "compilerOptions"
+    | "fileSet"
+    | "moduleResolutionCache"
+    | "targetDir"
+    | "projects"
   >,
   importerFile: string,
   importPath: string,
@@ -147,14 +214,36 @@ export function resolveLocalSourceFile(
   const file = normalizePath(
     path.relative(workspace.targetDir, resolved.resolvedFileName),
   );
-  if (file === ".." || file.startsWith("../")) return undefined;
-  return workspace.fileSet.has(file) ? file : undefined;
+  if (
+    workspace.fileSet.has(file) &&
+    (!projectForFile(workspace, file).prefix || isAnalysisSourceFile(file))
+  )
+    return file;
+  const canonicalFile =
+    ts.sys.realpath?.(resolved.resolvedFileName) ?? resolved.resolvedFileName;
+  for (const project of workspace.projects) {
+    if (!within(canonicalFile, project.canonicalDir)) continue;
+    const candidate = projectPath(
+      project,
+      path.relative(project.canonicalDir, canonicalFile),
+    );
+    if (
+      workspace.fileSet.has(candidate) &&
+      (!project.prefix || isAnalysisSourceFile(candidate))
+    )
+      return candidate;
+  }
+  return undefined;
 }
 
 export function resolveLocalModulePath(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
+    | "compilerOptions"
+    | "fileSet"
+    | "moduleResolutionCache"
+    | "targetDir"
+    | "projects"
   >,
   importerFile: string,
   importPath: string,
@@ -170,16 +259,34 @@ export function resolveLocalModulePath(
     return undefined;
   }
 
+  const project = projectForFile(workspace, importerFile);
+  if (
+    workspace.projects.length > 1 &&
+    (importPath.startsWith(".") ||
+      importPath.startsWith("#") ||
+      Object.keys(project.compilerOptions.paths ?? {}).some(
+        (pattern) =>
+          pattern !== "*" && modulePatternMatches(pattern, importPath),
+      ))
+  ) {
+    const resolved = resolveModule(workspace, importerFile, importPath);
+    if (resolved)
+      return normalizePath(
+        path.relative(
+          workspace.targetDir,
+          ts.sys.realpath?.(resolved.resolvedFileName) ??
+            resolved.resolvedFileName,
+        ),
+      );
+  }
+
   if (importPath.startsWith(".")) {
     return normalizePath(path.join(path.dirname(importerFile), importPath));
   }
 
-  const baseUrl = compilerPathsBase(
-    workspace.compilerOptions,
-    workspace.targetDir,
-  );
+  const baseUrl = compilerPathsBase(project.compilerOptions, project.targetDir);
   for (const [pattern, targets] of Object.entries(
-    workspace.compilerOptions.paths ?? {},
+    project.compilerOptions.paths ?? {},
   )) {
     if (pattern === "*") continue;
     const wildcardValue = modulePatternWildcard(pattern, importPath);
@@ -191,14 +298,22 @@ export function resolveLocalModulePath(
       const relative = normalizePath(
         path.relative(workspace.targetDir, absolute),
       );
-      if (relative !== ".." && !relative.startsWith("../")) return relative;
+      if (
+        workspace.projects.length > 1 ||
+        workspace.projects.some((candidate) =>
+          within(absolute, candidate.targetDir),
+        )
+      )
+        return relative;
     }
   }
 
   const relative = normalizePath(
     path.relative(workspace.targetDir, path.resolve(baseUrl, importPath)),
   );
-  return relative !== ".." && !relative.startsWith("../")
+  return workspace.projects.some((candidate) =>
+    within(path.resolve(workspace.targetDir, relative), candidate.targetDir),
+  )
     ? relative
     : undefined;
 }
@@ -206,13 +321,21 @@ export function resolveLocalModulePath(
 export function isLocalModuleSpecifier(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "fileSet" | "moduleResolutionCache" | "targetDir"
+    | "compilerOptions"
+    | "fileSet"
+    | "moduleResolutionCache"
+    | "targetDir"
+    | "projects"
   >,
   importerFile: string,
   importPath: string,
 ): boolean {
   const extension = path.posix.extname(importPath);
-  if (extension && !isAnalysisSourceFileExtension(extension)) {
+  if (
+    !importPath.startsWith("#") &&
+    extension &&
+    !isAnalysisSourceFileExtension(extension)
+  ) {
     return false;
   }
   if (importPath.startsWith(".")) return true;
@@ -222,12 +345,33 @@ export function isLocalModuleSpecifier(
     const file = normalizePath(
       path.relative(workspace.targetDir, resolved.resolvedFileName),
     );
-    return (
-      file !== ".." && !file.startsWith("../") && workspace.fileSet.has(file)
-    );
+    if (
+      workspace.fileSet.has(file) ||
+      resolveLocalSourceFile(workspace, importerFile, importPath)
+    )
+      return true;
+    // Package-import aliases can resolve to an omitted workspace through an
+    // install symlink. Keep normal dependencies inside node_modules external.
+    const canonical =
+      ts.sys.realpath?.(resolved.resolvedFileName) ?? resolved.resolvedFileName;
+    if (
+      importPath.startsWith("#") &&
+      !normalizePath(canonical).split("/").includes("node_modules")
+    )
+      return true;
   }
 
-  const pathPatterns = Object.keys(workspace.compilerOptions.paths ?? {});
+  const project = projectForFile(workspace, importerFile);
+  if (
+    workspace.projects.some(
+      (candidate) =>
+        candidate.name &&
+        (importPath === candidate.name ||
+          importPath.startsWith(`${candidate.name}/`)),
+    )
+  )
+    return true;
+  const pathPatterns = Object.keys(project.compilerOptions.paths ?? {});
   if (
     pathPatterns.some(
       (pattern) =>
@@ -239,7 +383,7 @@ export function isLocalModuleSpecifier(
     return true;
   }
 
-  const baseUrl = workspace.compilerOptions.baseUrl;
+  const baseUrl = project.compilerOptions.baseUrl;
   if (!baseUrl) return false;
   const firstSegment = importPath.split("/")[0];
   const prefix = normalizePath(
@@ -254,17 +398,18 @@ export function isLocalModuleSpecifier(
 function resolveModule(
   workspace: Pick<
     AnalysisWorkspace,
-    "compilerOptions" | "moduleResolutionCache" | "targetDir"
+    "compilerOptions" | "moduleResolutionCache" | "targetDir" | "projects"
   >,
   importerFile: string,
   importPath: string,
 ): ts.ResolvedModuleFull | undefined {
+  const project = projectForFile(workspace, importerFile);
   return ts.resolveModuleName(
     importPath,
     path.join(workspace.targetDir, importerFile),
-    workspace.compilerOptions,
+    project.compilerOptions,
     ts.sys,
-    workspace.moduleResolutionCache,
+    project.moduleResolutionCache,
   ).resolvedModule;
 }
 
@@ -341,3 +486,105 @@ function compilerPathsBase(
     compilerOptions.baseUrl ?? optionsWithPathBase.pathsBasePath ?? targetDir
   );
 }
+
+async function createProject(
+  appDir: string,
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<AnalysisProject> {
+  const manifest: unknown = files.includes("package.json")
+    ? JSON.parse(await readFile(path.join(targetDir, "package.json"), "utf8"))
+    : {};
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+    throw new Error(`Invalid package.json in ${targetDir}.`);
+  }
+  const data = manifest as Record<string, unknown>;
+  const dependencies = new Set<string>();
+  const localDependencies = new Set<string>();
+  for (const key of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+  ]) {
+    const value = data[key];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      for (const [name, specifier] of Object.entries(value)) {
+        dependencies.add(name);
+        if (
+          typeof specifier === "string" &&
+          /^(workspace|link|file):/.test(specifier) &&
+          !specifier.endsWith(".tgz")
+        )
+          localDependencies.add(name);
+      }
+    }
+  }
+  const { compilerConfigFiles, compilerOptions } =
+    resolveCompilerConfiguration(targetDir);
+  return {
+    targetDir,
+    canonicalDir: await realpath(targetDir),
+    prefix: normalizePath(path.relative(appDir, targetDir)),
+    ...(typeof data.name === "string" && data.name.trim()
+      ? { name: data.name }
+      : {}),
+    dependencies,
+    localDependencies,
+    config,
+    files,
+    compilerConfigFiles,
+    compilerOptions,
+    moduleResolutionCache: ts.createModuleResolutionCache(
+      targetDir,
+      ts.sys.useCaseSensitiveFileNames
+        ? (file) => file
+        : (file) => file.toLowerCase(),
+      compilerOptions,
+    ),
+  };
+}
+
+export function projectForFile(
+  workspace: Pick<AnalysisWorkspace, "projects" | "targetDir">,
+  file: string,
+): AnalysisProject {
+  return findProjectForFile(workspace, file) ?? workspace.projects[0];
+}
+
+export function findProjectForFile(
+  workspace: Pick<AnalysisWorkspace, "projects" | "targetDir">,
+  file: string,
+): AnalysisProject | undefined {
+  const absolute = path.resolve(workspace.targetDir, file);
+  return workspace.projects.find((project) =>
+    within(absolute, project.targetDir),
+  );
+}
+
+export function projectPath(project: AnalysisProject, file: string): string {
+  return normalizePath(path.join(project.prefix, file));
+}
+
+export function projectSource(
+  workspace: Pick<AnalysisWorkspace, "projects" | "targetDir">,
+  file: string,
+): { project: AnalysisProject; file: string } {
+  const project = projectForFile(workspace, file);
+  return {
+    project,
+    file: normalizePath(
+      path.relative(project.targetDir, path.resolve(workspace.targetDir, file)),
+    ),
+  };
+}
+
+function within(file: string, directory: string): boolean {
+  const relative = path.relative(directory, file);
+  return (
+    relative !== ".." &&
+    !relative.startsWith(`..${path.sep}`) &&
+    !path.isAbsolute(relative)
+  );
+}

package/src/app-map-changes.ts

@@ -216,8 +216,22 @@ export async function mapAppChanges(
     createAnalysisWorkspace(targetDir),
     resolveWorkspaceScope(git.repositoryRoot, canonicalTargetDir),
   ]);
+  for (const project of workspace.projects.slice(1)) {
+    if (isAbsoluteWithin(project.canonicalDir, git.repositoryRoot)) {
+      workspaceScope.dependencyDirectories.add(
+        normalizePath(path.relative(git.repositoryRoot, project.canonicalDir)),
+      );
+    }
+  }
   const governingFiles = new Set(
-    workspace.compilerConfigFiles
+    [
+      ...workspace.compilerConfigFiles,
+      ...workspace.projects.flatMap((project) =>
+        project.config.configFile
+          ? [path.join(project.targetDir, project.config.configFile)]
+          : [],
+      ),
+    ]
       .map((file) =>
         path.resolve(
           canonicalTargetDir,
@@ -285,6 +299,11 @@ export async function mapAppChanges(
     changedFiles,
     git.repositoryRoot,
     canonicalTargetDir,
+    workspace.projects
+      .slice(1)
+      .map((project) =>
+        normalizePath(path.relative(git.repositoryRoot, project.canonicalDir)),
+      ),
   );
   for (const change of appSourceChanges) {
     const directNodes = nodesByFile.get(change.file) ?? [];
@@ -750,6 +769,7 @@ function appRelativeSourceChanges(
   files: AppChangedFile[],
   repositoryRoot: string,
   canonicalTargetDir: string,
+  sourcePackages: string[],
 ): Array<{
   file: string;
   repositoryPath: string;
@@ -764,9 +784,15 @@ function appRelativeSourceChanges(
     status: GitChangedFileStatus;
   }> = [];
   for (const changed of files) {
-    if (changed.scope !== "app") continue;
+    if (changed.scope !== "app" && changed.scope !== "workspace-dependency")
+      continue;
     for (const repositoryPath of changedFilePaths(changed)) {
-      if (!isWithin(repositoryPath, targetPrefix)) continue;
+      if (
+        ![targetPrefix, ...sourcePackages].some((prefix) =>
+          isWithin(repositoryPath, prefix),
+        )
+      )
+        continue;
       const file = targetPrefix
         ? normalizePath(path.posix.relative(targetPrefix, repositoryPath))
         : repositoryPath;
@@ -1378,8 +1404,8 @@ function appWideChangeReasons(
     const message =
       scope === "workspace-dependency"
         ? scoped.length === 1
-          ? `Direct local dependency ${changedFile} changed.`
-          : `${scoped.length} direct local dependency files changed, including ${changedFile}.`
+          ? `Local source dependency ${changedFile} changed.`
+          : `${scoped.length} local source dependency files changed, including ${changedFile}.`
         : scoped.length === 1
           ? `Governing file ${changedFile} changed.`
           : `${scoped.length} governing files changed, including ${changedFile}.`;