@akanjs/devkit 3.0.0-beta.9 → 3.0.0

package/dependencyScanner.ts

@@ -7,11 +7,12 @@ import { FileSys } from "./fileSys";
 import type { PackageJson, TsConfigJson } from "./types";
 
 const testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
-// `__fixtures__` holds deliberately invalid sample sources for the lint-rule suites; tsconfig `exclude` and
-// biome's `!` override already skip them, and their imports are violations rather than real dependencies.
+// `__fixtures__` holds deliberately invalid lint-rule samples, whose imports are violations, not dependencies.
 const skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android", "__fixtures__"];
-const isSkippedPath = (filePath: string) =>
-  skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`));
+const isSkippedPath = (filePath: string) => {
+  const posixPath = filePath.split(path.sep).join("/");
+  return skipDirs.some((dir) => posixPath.includes(`/${dir}/`) || posixPath.startsWith(`${dir}/`));
+};
 const builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 const stripShebang = (source: string) => source.replace(/^#!.*(?:\r?\n|$)/, "");
 
@@ -73,11 +74,8 @@ export class TypeScriptDependencyScanner {
   ): Promise<{ npmDeps: string[]; npmDevDeps: string[]; missingDeps: string[] }> {
     const runtimeDeps = new Set<string>();
     const devDeps = new Set<string>();
-    const sourceFiles = await this.#findTypeScriptFiles(this.#directory, {
-      excludeBuildFiles: true,
-      excludeTestFiles: true,
-    });
-    const cssFiles = await this.#findCssFiles(this.#directory);
+    const sourceFiles = await this.#findFiles("**/*.{ts,tsx}", { excludeBuildFiles: true, excludeTestFiles: true });
+    const cssFiles = await this.#findFiles("**/*.css");
 
     for (const filePath of sourceFiles) {
       const fileContent = await FileSys.readText(filePath);
@@ -133,25 +131,19 @@ export class TypeScriptDependencyScanner {
     depSets: DepSets,
     fileDependencies: Map<string, string[]>,
   ): DepSets {
-    const importedDepSets = new Array<Set<string>>(depSets.length);
-    for (let i = 0; i < depSets.length; i++) importedDepSets[i] = new Set<string>();
-    fileDependencies.forEach((imps) => {
-      imps.forEach((imp) => {
-        if (imp.startsWith(".")) return;
-        const moduleName = imp;
-        const moduleNameParts = moduleName.split("/");
-        const subModuleLength = moduleNameParts.length;
-        for (let i = 0; i < subModuleLength; i++) {
-          const importName = moduleNameParts.slice(0, i + 1).join("/");
-          for (let j = 0; j < depSets.length; j++) {
-            if (depSets[j]?.has(importName)) {
-              importedDepSets[j]?.add(importName);
-              return;
-            }
-          }
+    const importedDepSets = depSets.map(() => new Set<string>());
+    for (const imps of fileDependencies.values())
+      for (const imp of imps) {
+        if (imp.startsWith(".")) continue;
+        const parts = imp.split("/");
+        for (let length = 1; length <= parts.length; length++) {
+          const importName = parts.slice(0, length).join("/");
+          const setIndex = depSets.findIndex((depSet) => depSet.has(importName));
+          if (setIndex === -1) continue;
+          importedDepSets[setIndex]?.add(importName);
+          break;
         }
-      });
-    });
+      }
     return importedDepSets as DepSets;
   }
 
@@ -161,48 +153,24 @@ export class TypeScriptDependencyScanner {
     this.#fileTypeDependencies.clear();
     this.#visitedFiles.clear();
 
-    const files = await this.#findTypeScriptFiles(this.#directory);
-
-    for (const file of files) await this.#analyzeFile(file, this.#directory);
-
+    for (const file of await this.#findFiles("**/*.{ts,tsx}")) await this.#analyzeFile(file, this.#directory);
     return this.#fileDependencies;
   }
 
-  async #findTypeScriptFiles(
-    directory: string,
+  async #findFiles(
+    pattern: string,
     {
       excludeBuildFiles = false,
       excludeTestFiles = false,
     }: { excludeBuildFiles?: boolean; excludeTestFiles?: boolean } = {},
   ): Promise<string[]> {
     const files: string[] = [];
-
-    const glob = new Bun.Glob("**/*.{ts,tsx}");
-    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+    for await (const filePath of new Bun.Glob(pattern).scan({ cwd: this.#directory, onlyFiles: true })) {
       if (isSkippedPath(filePath)) continue;
       if (excludeBuildFiles && filePath === "build.ts") continue;
       if (excludeTestFiles && testFileRegex.test(filePath)) continue;
-
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.#workspaceRoot, fullPath);
-      if (this.#ig.ignores(relativePath)) continue;
-
-      files.push(fullPath);
-    }
-    return files;
-  }
-
-  async #findCssFiles(directory: string): Promise<string[]> {
-    const files: string[] = [];
-    const glob = new Bun.Glob("**/*.css");
-    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
-      if (isSkippedPath(filePath)) continue;
-
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.#workspaceRoot, fullPath);
-      if (this.#ig.ignores(relativePath)) continue;
-
-      files.push(fullPath);
+      const fullPath = path.join(this.#directory, filePath);
+      if (!this.#ig.ignores(path.relative(this.#workspaceRoot, fullPath))) files.push(fullPath);
     }
     return files;
   }
@@ -215,12 +183,8 @@ export class TypeScriptDependencyScanner {
     try {
       const fileContent = await FileSys.readText(filePath);
       const { imports, typeImports } = this.#extractImports(fileContent, filePath);
-
-      // Convert imports to absolute or relative paths
       const resolvedImports = await this.#resolveImports(imports, filePath, baseDir);
       const resolvedTypeImports = await this.#resolveImports(typeImports, filePath, baseDir);
-
-      // Store the dependencies
       const relativePath = path.relative(baseDir, filePath);
       this.#fileDependencies.set(relativePath, [...new Set([...resolvedImports, ...resolvedTypeImports])]);
       this.#fileRuntimeDependencies.set(relativePath, resolvedImports);
@@ -233,12 +197,8 @@ export class TypeScriptDependencyScanner {
   async #resolveImports(imports: string[], filePath: string, baseDir: string): Promise<string[]> {
     return await Promise.all(
       imports.map(async (importPath) => {
-        if (importPath.startsWith(".")) {
-          // Handle relative imports
-          const resolvedPath = `./${path.join(path.relative(baseDir, filePath), importPath)}`;
-          return await this.#ensureExtension(resolvedPath);
-        }
-        return importPath; // Keep package imports as is
+        if (!importPath.startsWith(".")) return importPath;
+        return await this.#ensureExtension(`./${path.join(path.relative(baseDir, filePath), importPath)}`);
       }),
     );
   }
@@ -324,19 +284,10 @@ export class TypeScriptDependencyScanner {
       const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
       const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
 
-      if (projectImports.length > 0) {
-        graph += "  Project dependencies:\n";
-        projectImports.forEach((imp) => {
-          graph += `    → ${imp}\n`;
-        });
-      }
-
-      if (externalImports.length > 0) {
-        graph += "  External dependencies:\n";
-        externalImports.forEach((imp) => {
-          graph += `    → ${imp}\n`;
-        });
-      }
+      if (projectImports.length > 0)
+        graph += `  Project dependencies:\n${projectImports.map((imp) => `    → ${imp}\n`).join("")}`;
+      if (externalImports.length > 0)
+        graph += `  External dependencies:\n${externalImports.map((imp) => `    → ${imp}\n`).join("")}`;
 
       graph += "\n";
     }

package/devkitUtils.test.ts

@@ -1,29 +1,14 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
+import { describe, expect, test } from "bun:test";
+import { realpath } from "node:fs/promises";
 import path from "node:path";
 import { ApplicationBuildReporter } from "./applicationBuildReporter";
 import { resolveSignalTestPreloadPath } from "./applicationTestPreload";
 import { TypeScriptDependencyScanner } from "./dependencyScanner";
 import { AppExecutor, WorkspaceExecutor } from "./executors";
+import { tempDirs, writeText as write } from "./testHelpers";
 import type { PackageJson, TsConfigJson } from "./types";
 
-const tempRoots: string[] = [];
-
-const makeTempRoot = async () => {
-  const root = await mkdtemp(path.join(os.tmpdir(), "akan-devkit-utils-"));
-  tempRoots.push(root);
-  return root;
-};
-
-const write = async (filePath: string, content: string) => {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, content);
-};
-
-afterEach(async () => {
-  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
-});
+const makeTempRoot = tempDirs("akan-devkit-utils-");
 
 describe("resolveSignalTestPreloadPath", () => {
   test("resolves the preload file from an installed akanjs package", async () => {
@@ -40,7 +25,7 @@ describe("resolveSignalTestPreloadPath", () => {
     await write(path.join(root, "node_modules/akanjs/test/signalTest.preload.ts"), "export {};\n");
 
     await expect(resolveSignalTestPreloadPath({ cwdPath: libDir })).resolves.toContain(
-      "node_modules/akanjs/test/signalTest.preload.ts",
+      path.join("node_modules/akanjs/test/signalTest.preload.ts"),
     );
   });
 });
@@ -213,4 +198,47 @@ describe("ApplicationBuildReporter", () => {
       ["failed", "  first", "  second", "  third"].join("\n"),
     );
   });
+
+  test("says where the bundler placed each reason, relative to the workspace root", async () => {
+    const root = await makeTempRoot();
+    const refuseWith = (message: string) => ({
+      name: "refuse",
+      setup: (build: Bun.PluginBuilder) => {
+        build.onLoad({ filter: /plugged\.ts$/ }, () => {
+          throw new Error(message);
+        });
+      },
+    });
+    const failureOf = (entry: string, plugins: Bun.BunPlugin[] = []) =>
+      Bun.build({ entrypoints: [path.join(root, entry)], plugins }).then(
+        () => null,
+        (error: unknown) => error,
+      );
+    await write(
+      path.join(root, "src/entry.ts"),
+      'export const a = 1;\nimport { gone } from "./not-there";\nexport const b = gone;\n',
+    );
+    await write(path.join(root, "src/plugged.ts"), "export const b = 1;\n");
+
+    const unresolved = await failureOf("src/entry.ts");
+    expect(ApplicationBuildReporter.formatError(unresolved, root)).toBe(
+      ["Bundle failed", '  Could not resolve: "./not-there" (src/entry.ts:2:22)'].join("\n"),
+    );
+    const outside = path.join(await realpath(root), "src/entry.ts");
+    expect(ApplicationBuildReporter.formatError(unresolved, path.join(root, "elsewhere"))).toBe(
+      ["Bundle failed", `  Could not resolve: "./not-there" (${outside}:2:22)`].join("\n"),
+    );
+    expect(
+      ApplicationBuildReporter.formatError(
+        await failureOf("src/plugged.ts", [refuseWith("refused\nsecond line")]),
+        root,
+      ),
+    ).toBe(["Bundle failed", "  refused (src/plugged.ts)", "  second line"].join("\n"));
+    expect(
+      ApplicationBuildReporter.formatError(
+        await failureOf("src/plugged.ts", [refuseWith("src/plugged.ts is refused")]),
+        root,
+      ),
+    ).toBe(["Bundle failed", "  src/plugged.ts is refused"].join("\n"));
+  });
 });

package/executors.linkFallback.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import * as fsPromises from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+//? The Windows VM runs as an administrator, so a refused link only ever happens here — injected, on every OS.
+const realSymlink = fsPromises.symlink;
+let refuseLinks = false;
+mock.module("node:fs/promises", () => ({
+  ...fsPromises,
+  symlink: async (...args: Parameters<typeof fsPromises.symlink>) => {
+    if (refuseLinks)
+      throw Object.assign(new Error(`EPERM: operation not permitted, symlink '${String(args[0])}'`), {
+        code: "EPERM",
+      });
+    return await realSymlink(...args);
+  },
+}));
+const { AppExecutor, WorkspaceExecutor } = await import("./executors");
+
+const { lstat, mkdir, mkdtemp, readFile, rm, writeFile } = fsPromises;
+const originalEnv = { ...process.env };
+const originalPlatform = process.platform;
+const tempRoots: string[] = [];
+const PAGE_SOURCE = "export default function Page() {\n  return null;\n}\n";
+
+const setPlatform = (platform: NodeJS.Platform) =>
+  Object.defineProperty(process, "platform", { value: platform, configurable: true, writable: true });
+
+// `AppExecutor.from` memoises by name, so each test needs a name no other test has used.
+const makeApp = async (appName: string) => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "akan-link-fallback-"));
+  tempRoots.push(root);
+  process.env.AKAN_PUBLIC_REPO_NAME = "repo";
+  process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
+  process.env.AKAN_PUBLIC_ENV = "local";
+  process.env.PORT_OFFSET = "0";
+  await writeFile(path.join(root, "package.json"), JSON.stringify({ name: "fixture", version: "1.0.0" }));
+  await mkdir(path.join(root, "libs/shared/public"), { recursive: true });
+  await writeFile(path.join(root, "libs/shared/public/logo.png"), "logo");
+  await mkdir(path.join(root, "libs/shared/page/about"), { recursive: true });
+  await writeFile(path.join(root, "libs/shared/page/about/_index.tsx"), PAGE_SOURCE);
+  await mkdir(path.join(root, "apps", appName, "page"), { recursive: true });
+  await writeFile(path.join(root, "apps", appName, "akan.config.ts"), "export default { syncPageLibs: true };\n");
+  const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
+  return { root, app: AppExecutor.from(workspace, appName), appRoot: path.join(root, "apps", appName) };
+};
+
+beforeEach(() => {
+  process.env = { ...originalEnv };
+  refuseLinks = true;
+});
+
+afterEach(async () => {
+  refuseLinks = false;
+  setPlatform(originalPlatform);
+  process.env = { ...originalEnv };
+  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("lib links the OS refuses to create", () => {
+  test("Windows gets a copy of the lib assets, and a resync replaces it without touching the lib", async () => {
+    setPlatform("win32");
+    const { root, app, appRoot } = await makeApp("fallback-assets");
+
+    await app.syncAssets(["shared"]);
+    const copied = path.join(appRoot, "public/libs/shared");
+    expect((await lstat(copied)).isSymbolicLink()).toBe(false);
+    expect(await readFile(path.join(copied, "logo.png"), "utf8")).toBe("logo");
+
+    await writeFile(path.join(root, "libs/shared/public/logo.png"), "logo-v2");
+    await app.syncAssets(["shared"]);
+    expect(await readFile(path.join(copied, "logo.png"), "utf8")).toBe("logo-v2");
+
+    await app.syncAssets([]);
+    expect(await lstat(path.join(appRoot, "public/libs")).catch(() => null)).toBeNull();
+    expect(await readFile(path.join(root, "libs/shared/public/logo.png"), "utf8")).toBe("logo-v2");
+  });
+
+  test("Windows gets a copy of the lib pages that still routes, and a resync picks up a new lib route", async () => {
+    setPlatform("win32");
+    const { root, app, appRoot } = await makeApp("fallback-pages");
+
+    expect(await app.syncPages(["shared"])).toBe(true);
+    expect((await lstat(path.join(appRoot, "page/(libs)/(shared)"))).isSymbolicLink()).toBe(false);
+    expect(await app.getPageKeys({ refresh: true })).toEqual(["./(libs)/(shared)/about/_index.tsx"]);
+
+    await mkdir(path.join(root, "libs/shared/page/terms"), { recursive: true });
+    await writeFile(path.join(root, "libs/shared/page/terms/_index.tsx"), PAGE_SOURCE);
+    expect(await app.syncPages(["shared"])).toBe(true);
+    expect(await app.getPageKeys({ refresh: true })).toEqual([
+      "./(libs)/(shared)/about/_index.tsx",
+      "./(libs)/(shared)/terms/_index.tsx",
+    ]);
+  });
+
+  test("elsewhere the refusal surfaces rather than being papered over with a copy", async () => {
+    setPlatform(originalPlatform === "win32" ? "linux" : originalPlatform);
+    const { app } = await makeApp("fallback-posix");
+
+    await expect(app.syncAssets(["shared"])).rejects.toThrow("EPERM");
+  });
+});