sailfork / t3code-github / .repos/ alchemy-effect/ packages/ alchemy/ src/ Bundle/ Vite.ts

import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import type { PlatformError } from "effect/PlatformError";
import type * as vite from "vite";
import { cachedFunction } from "../Util/cached-function.ts";
import { sha256 } from "../Util/index.ts";
import {
  BundleError,
  bundleErrorFromUnknown,
  bundleOutputFromFiles,
  type BundleFile,
  type BundleOutput,
} from "./Bundle.ts";

export interface ViteBuildOutput {
  readonly clientDirectory: string | undefined;
  /**
   * The client environment's resolved Vite `base`. The build rewrites
   * every emitted asset URL with it, so the uploaded asset manifest must
   * be keyed with the same prefix to agree with the HTML.
   */
  readonly base: string | undefined;
  // This is emitted as an Effect instead of a value so we can process it in parallel with reading the client assets.
  readonly serverBundle: Effect.Effect<BundleOutput | undefined, BundleError>;
  readonly externalWorkspaces: Effect.Effect<Set<string>, PlatformError>;
}

// `@vitejs/plugin-rsc` writes these modules separately after build completes instead of emitting them as chunks.
// So, we need to detect them and read them from the file system manually.
const RSC_MANIFEST = {
  "virtual:vite-rsc/assets-manifest": "__vite_rsc_assets_manifest.js",
  "virtual:vite-rsc/environment-imports": "__vite_rsc_env_imports_manifest.js",
} as const;

/**
 * Structural subset of `vite.Environment` used by the bundling helpers.
 * Typed structurally rather than as `vite.Environment` so plugin hooks whose
 * `this` context is typed against a different vite copy in the install graph
 * (bun peer-variant duplication) still assign.
 */
interface EnvironmentLike {
  readonly name: string;
  readonly config: {
    readonly base: string;
    readonly root: string;
    readonly build: { readonly outDir: string };
  };
}

/** Whether `directory` exists and is not empty. */
const isNonEmptyDirectory = Effect.fn(function* (
  fs: FileSystem.FileSystem,
  directory: string | undefined,
) {
  if (!directory || !(yield* fs.exists(directory))) return false;
  return (yield* fs.readDirectory(directory)).length > 0;
});

/**
 * A Vite plugin that collects the output of the build and makes it available as an Effect.
 * @param entryEnvironment - The environment to use as the entry point for the server bundle. Defaults to "ssr".
 */
export const viteBuildOutputPlugin = Effect.fn(function* ({
  entryEnvironment = "ssr",
}: {
  entryEnvironment?: string;
}) {
  const fs = yield* FileSystem.FileSystem;
  const path = yield* Path.Path;
  let clientDirectory: string | undefined;
  let base: string | undefined;
  // Where the client build writes, and the `public/` it would copy. Read from
  // the resolved config because the client environment may never build.
  let clientOutDir: string | undefined;
  let publicDir: string | undefined;
  // Assets the entry environment imports by URL (`import url from
  // "./logo.png"`), keyed by output file name. They belong with the static
  // assets, not in the Worker bundle.
  const importedAssets = new Map<string, string>();
  let serverEntry: string | undefined;
  // `undefined` for an output a plugin removed after writing it (Vike deletes
  // its `.vite/manifest.json`): it isn't deployed, as with Wrangler.
  const serverChunks = new Map<string, Effect.Effect<BundleFile | undefined, BundleError>>();
  const maybeExternalWorkspaces = new Set<string>();

  const findUp = yield* cachedFunction(
    (dir: string, filenames: Array<string>): Effect.Effect<string | undefined, PlatformError> =>
      Effect.filter(
        filenames.map((filename) => path.join(dir, filename)),
        fs.exists,
        { concurrency: "unbounded" },
      ).pipe(
        Effect.flatMap(([match]) => {
          if (match) {
            return Effect.succeed(match);
          }
          const parent = path.dirname(dir);
          if (parent === dir) {
            return Effect.undefined;
          }
          return findUp(parent, filenames);
        }),
      ),
  );
  const collectExternalWorkspaces = (): Effect.Effect<Set<string>, PlatformError> =>
    Effect.forEach(maybeExternalWorkspaces, (directory) =>
      findUp(directory, ["package.json"]),
    ).pipe(
      Effect.map((paths) => new Set(paths.filter((file) => file !== undefined).map(path.dirname))),
    );
  const plugin: vite.Plugin = {
    name: "alchemy:build-output",
    sharedDuringBuild: true,
    configResolved(config) {
      const outDir = config.environments?.client?.build.outDir;
      clientOutDir = outDir === undefined ? undefined : path.resolve(config.root, outDir);
      publicDir = config.publicDir || undefined;
    },
    // Collect the client output directory and server chunks as each
    // environment writes its bundle. We deliberately do NOT resolve the build
    // result from a `buildApp` hook: on Vite 8, when a project declares no
    // `builder.buildApp` (e.g. a plain client-only SPA), `builder.buildApp()`
    // runs post-order `buildApp` hooks *before* the default environment builds,
    // so a hook fires while the output is still empty (issue #792). Instead,
    // `viteBuild` reads `output` *after* `builder.buildApp()` resolves — by
    // which point every environment that actually built has run `writeBundle`.
    async writeBundle(_, bundle) {
      const root = path.resolve(this.environment.config.root);
      for (const id of this.getModuleIds()) {
        if (!path.isAbsolute(id) || id.includes("node_modules") || id.startsWith(root)) {
          continue;
        }
        maybeExternalWorkspaces.add(path.dirname(id));
      }
      if (this.environment.name === "client") {
        clientDirectory = path.resolve(root, this.environment.config.build.outDir);
        base = this.environment.config.base;
        return;
      }
      const files = Object.values(bundle);
      if (this.environment.name === entryEnvironment) {
        // Frameworks can add entries of their own (Vike's export-less
        // `entry.mjs`), so prefer the `index` entry the Cloudflare plugin
        // names the Worker, then one with exports.
        const entryChunks = files.filter(
          (file): file is vite.Rolldown.OutputChunk => file.type === "chunk" && file.isEntry,
        );
        const entryChunk =
          entryChunks.find((chunk) => chunk.name === "index") ??
          entryChunks.find((chunk) => chunk.exports.length > 0) ??
          entryChunks[0];
        if (!entryChunk) {
          throw new Error(`Entry chunk not found for environment "${this.environment.name}"`);
        }
        serverEntry = fileName(entryChunk.fileName, this.environment);
      }
      const outDir = path.resolve(root, this.environment.config.build.outDir);
      const urlAssets = new Set<string>();
      for (const file of files) {
        if (file.type !== "chunk" || this.environment.name !== entryEnvironment) continue;
        const metadata = (file as { viteMetadata?: { importedAssets?: Set<string> } }).viteMetadata;
        for (const asset of metadata?.importedAssets ?? []) {
          urlAssets.add(asset);
          importedAssets.set(asset, path.join(outDir, asset));
        }
      }
      await Promise.all(
        files.map(async (file) => {
          if (file.type === "asset" && urlAssets.has(file.fileName)) return;
          // Vite's build metadata (`.vite/manifest.json`), not a Worker module.
          if (file.fileName.startsWith(".vite/")) return;
          if (file.type === "chunk") {
            file.imports
              .filter((self): self is keyof typeof RSC_MANIFEST => self in RSC_MANIFEST)
              .forEach((id) => {
                // Key by the environment-prefixed path, NOT the bare manifest
                // filename. `@vitejs/plugin-rsc` emits a copy of the same-named
                // manifest into every environment's outDir (e.g. both
                // `dist/rsc/__vite_rsc_assets_manifest.js` and
                // `dist/ssr/__vite_rsc_assets_manifest.js`), and each
                // environment's chunks import their own copy via a relative
                // specifier. Keying by the bare filename collapses them into a
                // single entry, dropping every copy but the last — so the
                // entry worker's `import "../__vite_rsc_assets_manifest.js"`
                // resolves to a module that isn't in the bundle and the
                // deployed Worker fails at startup.
                serverChunks.set(
                  fileName(RSC_MANIFEST[id], this.environment),
                  readOutputFile(RSC_MANIFEST[id], this.environment),
                );
              });
          }
          // Read back from disk once the build completes, as Wrangler deploys
          // the output directory: plugins can rewrite written chunks in their
          // own `writeBundle` (Vike inlines its assets manifest there).
          serverChunks.set(
            fileName(file.fileName, this.environment),
            readOutputFile(file.fileName, this.environment),
          );
        }),
      );
    },
  };

  // The server bundle may include chunks from more than one Vite environment, so we need to prefix them with the environment-specific output directory.
  // Flattening them doesn't work because of relative imports between environments.
  //
  // `build.outDir` can be resolved to an absolute path (e.g. `@vitejs/plugin-rsc`
  // does this), which would leak the build machine's filesystem path into the
  // worker module names and produce non-portable, leading-`/` specifiers that
  // Cloudflare rejects. Normalize it back to a path relative to the project root
  // so module names match the single-environment case (`dist/ssr/worker.js`).
  const fileName = (name: string, environment: EnvironmentLike) => {
    const outDir = environment.config.build.outDir;
    const relativeOutDir = path.isAbsolute(outDir)
      ? path.relative(environment.config.root, outDir)
      : outDir;
    // `path.relative` (and user-configured outDirs) yield backslashes on
    // Windows; worker module names are import specifiers, so a name like
    // `dist\ssr/index.js` deploys fine but can never be resolved by the
    // entry's `import "ssr/index.js"` — the worker 1101s at request time.
    return `${relativeOutDir.replaceAll("\\", "/")}/${name}`;
  };

  // Read an output file from the file system.
  // This is only safe to run *after* the build has completed.
  const readOutputFile = (name: string, environment: EnvironmentLike) => {
    const file = path.resolve(environment.config.root, environment.config.build.outDir, name);
    return fs.exists(file).pipe(
      Effect.flatMap((exists) => (exists ? readFile(file, name, environment) : Effect.undefined)),
      Effect.mapError(bundleErrorFromUnknown),
    );
  };

  const readFile = (file: string, name: string, environment: EnvironmentLike) =>
    fs.readFile(file).pipe(
      Effect.flatMap((content) =>
        sha256(content).pipe(
          Effect.map((hash): BundleFile => ({
            path: fileName(name, environment),
            content,
            hash,
          })),
        ),
      ),
      Effect.mapError(bundleErrorFromUnknown),
    );

  const makeServerBundle = () => {
    if (!serverEntry && !serverChunks.size) return Effect.undefined;
    if (!serverEntry) return Effect.die(new Cause.NoSuchElementError("Missing server entry"));
    const filePaths = Array.from(serverChunks.keys()).sort((a, b) => a.localeCompare(b));
    const entry = getChunk(serverEntry).pipe(
      Effect.flatMap((file) =>
        file
          ? Effect.succeed(file)
          : Effect.die(new Cause.NoSuchElementError(`Chunk ${serverEntry} not found`)),
      ),
    );
    const rest = filePaths
      .filter((filePath) => filePath !== serverEntry)
      .map((filePath) => getChunk(filePath));
    return Effect.all([entry, ...rest], { concurrency: "unbounded" }).pipe(
      Effect.flatMap(([entryFile, ...files]) =>
        bundleOutputFromFiles([
          entryFile,
          ...files.filter((file): file is BundleFile => file !== undefined),
        ]),
      ),
    );
  };

  // Mirrors `@cloudflare/vite-plugin`: assets the Worker imports move to the
  // client output. Without a client build (no `index.html`), Vite never copies
  // `public/` (the Worker builds with `copyPublicDir: false`), so the client
  // output is created from `public/` plus those assets, as the plugin's
  // fallback client build does.
  const collectAssets = Effect.fn(function* () {
    let directory = clientDirectory;
    if (directory === undefined) {
      const hasPublic = yield* isNonEmptyDirectory(fs, publicDir);
      if (clientOutDir === undefined || (!hasPublic && importedAssets.size === 0)) {
        return undefined;
      }
      directory = clientOutDir;
      yield* fs.remove(directory, { recursive: true, force: true });
      yield* fs.makeDirectory(directory, { recursive: true });
      if (hasPublic) yield* fs.copy(publicDir!, directory);
    }
    for (const [asset, source] of importedAssets) {
      const destination = path.join(directory, asset);
      if (yield* fs.exists(destination)) continue;
      yield* fs.makeDirectory(path.dirname(destination), { recursive: true });
      yield* fs.copyFile(source, destination);
    }
    return directory;
  });

  const getChunk = (path: string) => {
    const chunk = serverChunks.get(path);
    if (!chunk) {
      return Effect.die(new Cause.NoSuchElementError(`Chunk ${path} not found`));
    }
    return chunk;
  };

  return {
    plugin,
    // Read lazily so callers observe the state collected during the build.
    // Only safe to await *after* `builder.buildApp()` has resolved.
    output: Effect.gen(function* () {
      const assetsDirectory = yield* collectAssets();
      return {
        clientDirectory: assetsDirectory,
        base,
        serverBundle: makeServerBundle(),
        externalWorkspaces: collectExternalWorkspaces(),
      };
    }),
  };
});