builder.ts

import { existsSync, mkdirSync, rmSync } from "fs";
import { relative, extname, join, normalize, resolve } from "path";
import { insertGenerateScript } from "./script";
import {
  functionBatch,
  getEntrypoints,
  logger,
  mode,
  scanServerModule,
  toPosix,
} from "./globals";
import type { BunSaiPluginArtifact } from "./plugins";
import registerPlugins from "./plugins";

export const BuildFiles = Symbol("build.build-files");

export interface BuilderArgs {
  /**
   * @default "./app"
   */
  rootFolder: string;
  /**
   * @default "./.bunsai"
   */
  outFolder: string;
  /**
   * default: {@link mode}
   */
  mode: "prod" | "dev";
  /**
   * To be used by Glob to hide a file or a folder.
   *
   * Can be set to `""` to disable it.
   *
   * Can be used to avoid glob matching conflicts with other APIs.
   * @default "$" // any file or folder starting with "$" will be ignored
   */
  globHideToken: string;
  pluginsArtifact: BunSaiPluginArtifact[];
  /**
   * @default "/assets/"
   */
  assetsPath: AssetPath;
}

export interface BuilderInitArgs
  extends Partial<Omit<BuilderArgs, "pluginsArtifact">> {
  plugins: BunSaiPlugin[];
}

export class Builder implements BuilderArgs {
  readonly mode: "prod" | "dev";
  readonly onWebBuild: (config: BuildConfig, mode: Mode) => void;
  readonly onBunBuild: (config: BuildConfig, mode: Mode) => void;
  readonly pluginsArtifact: BunSaiPluginArtifact[];
  readonly outFolder: string;
  readonly rootFolder: string;
  readonly globHideToken: string;
  readonly serverRoutes: string;
  readonly clientRoutes: string;
  readonly serverGlobString: string;
  readonly clientGlobString: string;
  readonly serverGlob: InstanceType<typeof Bun.Glob>;
  readonly clientGlob: InstanceType<typeof Bun.Glob>;
  readonly pluginImports: string[];
  readonly assetsPath: AssetPath;

  protected constructor(args: BuilderArgs) {
    this.rootFolder = args.rootFolder;
    this.mode = args.mode;
    this.globHideToken = args.globHideToken;
    this.outFolder = args.outFolder;
    this.pluginsArtifact = args.pluginsArtifact;
    this.serverRoutes = normalize(`${this.outFolder}/server`);
    this.clientRoutes = normalize(`${this.outFolder}/client`);
    this.assetsPath = args.assetsPath;
    this.pluginImports = this.pluginsArtifact.flatMap(
      ({ origin }) => origin.imports || []
    );

    this.onBunBuild = functionBatch(
      this.pluginsArtifact
        .filter(({ origin }) => origin.onBunBuild)
        .map(({ origin }) => origin.onBunBuild!)
    );

    this.onWebBuild = functionBatch(
      this.pluginsArtifact
        .filter(({ origin }) => origin.onWebBuild)
        .map(({ origin }) => origin.onWebBuild!)
    );

    const serverExtList = Array.from(
      new Set(
        this.pluginsArtifact.flatMap(({ origin }) =>
          getEntrypoints(origin, "bun")
        )
      )
    );

    const clientExtList = Array.from(
      new Set(
        this.pluginsArtifact.flatMap(({ origin }) =>
          getEntrypoints(origin, "web")
        )
      )
    );

    this.serverGlobString = `${this.rootFolder}/**/*{${serverExtList}}`;
    this.clientGlobString = `${this.rootFolder}/**/*{${clientExtList}}`;
    this.serverGlob = new Bun.Glob(this.serverGlobString);
    this.clientGlob = new Bun.Glob(this.clientGlobString);
  }

  async build(): Promise<BunSaiBuildResult> {
    logger.time`${(c) => c.green("Build time")}`;

    const _serverEntrypoints = await Array.fromAsync(this.serverGlob.scan());
    const _clientEntrypoints = await Array.fromAsync(this.clientGlob.scan());

    const serverEntrypoints = this.globHideToken
      ? _serverEntrypoints.filter(
          (entry) => !entry.includes(this.globHideToken)
        )
      : _serverEntrypoints;

    const clientEntrypoints = this.globHideToken
      ? _clientEntrypoints.filter(
          (entry) => !entry.includes(this.globHideToken)
        )
      : _clientEntrypoints;

    const { clientRoutes, serverRoutes } = this;

    if (serverEntrypoints.length == 0 && clientEntrypoints.length == 0) {
      if (!existsSync(clientRoutes))
        mkdirSync(clientRoutes, { recursive: true });
      if (!existsSync(serverRoutes))
        mkdirSync(serverRoutes, { recursive: true });

      throw new AggregateError([
        `No files were found matching "${this.serverGlobString}"`,
        `No files were found matching "${this.clientGlobString}"`,
      ]);
    }

    logger.info`${(c) => c.yellow.bold("Building:")}`;
    logger.info` ${Array.from(
      new Set(clientEntrypoints.concat(serverEntrypoints))
    ).join("\n ")}`;

    const serverBuild: BuildConfig = {
      root: this.rootFolder,
      entrypoints: serverEntrypoints,
      target: "bun",
      outdir: serverRoutes,
      // publicPath: toPosix(resolve(serverRoutes)) + "/",
      plugins: this.pluginsArtifact.flatMap(({ bun }) => bun),
      minify: this.mode == "prod",
      splitting: true,
    };

    this.onBunBuild(serverBuild, this.mode);

    const server = await Bun.build(serverBuild);

    if (!server.success) throw new AggregateError(server.logs);

    const clientBuild: BuildConfig = {
      root: this.rootFolder,
      entrypoints: clientEntrypoints,
      target: "browser",
      outdir: clientRoutes,
      plugins: this.pluginsArtifact.flatMap(({ web }) => web),
      naming: {
        asset: "[dir]/[name].[ext]",
      },
      minify: this.mode == "prod",
      splitting: true,
    };

    this.onWebBuild(clientBuild, this.mode);

    const client = await Bun.build(clientBuild);

    if (!client.success) throw new AggregateError(client.logs);

    const result: Omit<BunSaiBuildResult, "generateScript"> = {
      root: this.rootFolder,
      clientEntrypoints,
      serverEntrypoints,
      client: client.outputs.map((output) => {
        const assetPath = relative(resolve(clientRoutes), output.path);

        return {
          publicPath: toPosix(normalize(`${this.assetsPath}${assetPath}`)),
          file: output,
          relativePath: toPosix(join(clientRoutes, assetPath)),
        };
      }),
      server: await Promise.all(
        server.outputs
          .filter(({ kind }) => kind == "entry-point")
          .map(async (art, i) => {
            const assetPath = relative(resolve(serverRoutes), art.path);

            const sourceExt = extname(serverEntrypoints[i]);

            const plugin = this.pluginsArtifact.find(({ origin }) =>
              getEntrypoints(origin, "bun").includes(sourceExt)
            );

            if (!plugin)
              throw new Error(`BunSai bug: plugin not found for "${art.path}"`);

            return {
              publicPath: toPosix(normalize(`${this.assetsPath}${assetPath}`)),
              path: toPosix(
                normalize(
                  `/${assetPath
                    .replaceAll("index", "")
                    .replaceAll("[...]", "*")
                    .replaceAll(/\[(\w+)\]/g, ":$1")
                    .replace(/\.\w+$/, "")}`
                )
              ),
              origin: plugin.origin,
              moduloPath: art.path,
              modulo: scanServerModule(await art.text()),
            };
          })
      ),
    };

    logger.timeEnd`${(c) => c.green("Build time")}`;

    return insertGenerateScript(result, this.pluginImports, this.mode);
  }

  resetOutFolder() {
    if (existsSync(this.outFolder)) rmSync(this.outFolder, { recursive: true });

    mkdirSync(this.outFolder, { recursive: true });
  }

  static async init(args: BuilderInitArgs) {
    const _mode = args.mode || mode;

    const instance = new this({
      rootFolder: args.rootFolder || "./app",
      mode: _mode,
      globHideToken: args.globHideToken ?? "$",
      outFolder: args.outFolder || "./.bunsai",
      pluginsArtifact: await registerPlugins(args.plugins, _mode),
      assetsPath: args.assetsPath || "/assets/",
    });

    instance.resetOutFolder();

    return instance;
  }
}