bknd/app/build.ts

import { $ } from "bun";
import * as tsup from "tsup";
import pkg from "./package.json" with { type: "json" };
import c from "picocolors";
import { watch as fsWatch, readdirSync, rmSync } from "node:fs";
import { join } from "node:path";

const args = process.argv.slice(2);
const watch = args.includes("--watch");
const minify = args.includes("--minify");
const types = args.includes("--types");
const sourcemap = args.includes("--sourcemap");
const clean = args.includes("--clean");

// silence tsup
const oldConsole = {
  log: console.log,
  warn: console.warn,
};
console.log = () => {};
console.warn = () => {};

const define = {
  __isDev: "0",
  __version: JSON.stringify(pkg.version),
};

if (clean) {
   console.info("Cleaning dist (w/o static)");
   // Cross-platform clean: remove all files/folders in dist except static
   const distPath = join(import.meta.dir, "dist");
   try {
      const entries = readdirSync(distPath);
      for (const entry of entries) {
         if (entry === "static") continue;
         const entryPath = join(distPath, entry);
         rmSync(entryPath, { recursive: true, force: true });
      }
   } catch (e) {
      // dist may not exist yet, ignore
   }
}

let types_running = false;
function buildTypes() {
  if (types_running || !types) return;
  types_running = true;

  Bun.spawn(["bun", "build:types"], {
    stdout: "inherit",
    onExit: () => {
      oldConsole.log(c.cyan("[Types]"), c.green("built"));
      Bun.spawn(["bun", "tsc-alias"], {
        stdout: "inherit",
        onExit: () => {
          oldConsole.log(c.cyan("[Types]"), c.green("aliased"));
          types_running = false;
        },
      });
    },
  });
}

if (types && !watch) {
  buildTypes();
}

let watcher_timeout: any;
function delayTypes() {
  if (!watch || !types) return;
  if (watcher_timeout) {
    clearTimeout(watcher_timeout);
  }
  watcher_timeout = setTimeout(buildTypes, 1000);
}

const dependencies = Object.keys(pkg.dependencies);

// collection of always-external packages
const external = [
  ...dependencies,
  "bun:test",
  "node:test",
  "node:assert/strict",
  "@libsql/client",
  "bknd",
  /^bknd\/.*/,
  "jsonv-ts",
  /^jsonv-ts\/.*/,
] as const;

/**
 * Building backend and general API
 */
async function buildApi() {
  await tsup.build({
    minify,
    sourcemap,
    // don't use tsup's broken watch, we'll handle it ourselves
    watch: false,
    define,
    entry: [
      "src/index.ts",
      "src/core/utils/index.ts",
      "src/plugins/index.ts",
      "src/modes/index.ts",
    ],
    outDir: "dist",
    external: [...external],
    metafile: true,
    target: "esnext",
    platform: "browser",
    removeNodeProtocol: false,
    format: ["esm"],
    splitting: false,
    loader: {
      ".svg": "dataurl",
    },
    onSuccess: async () => {
      delayTypes();
      oldConsole.log(c.cyan("[API]"), c.green("built"));
    },
  });
}

async function rewriteClient(path: string) {
  const bundle = await Bun.file(path).text();
  await Bun.write(
    path,
    '"use client";\n' + bundle.replaceAll("ui/client", "bknd/client"),
  );
}

/**
 * Building UI for direct imports
 */
async function buildUi() {
  const base = {
    minify,
    sourcemap,
    watch: false,
    define,
    external: [
      ...external,
      "react",
      "react-dom",
      "react/jsx-runtime",
      "react/jsx-dev-runtime",
      "use-sync-external-store",
      /codemirror/,
      "@xyflow/react",
      "@mantine/core",
    ],
    metafile: true,
    platform: "browser",
    format: ["esm"],
    splitting: false,
    bundle: true,
    treeshake: true,
    loader: {
      ".svg": "dataurl",
    },
    esbuildOptions: (options) => {
      options.logLevel = "silent";
    },
  } satisfies tsup.Options;

  await tsup.build({
    ...base,
    entry: ["src/ui/index.ts", "src/ui/main.css", "src/ui/styles.css"],
    outDir: "dist/ui",
    onSuccess: async () => {
      await rewriteClient("./dist/ui/index.js");
      delayTypes();
      oldConsole.log(c.cyan("[UI]"), c.green("built"));
    },
  });

  await tsup.build({
    ...base,
    entry: ["src/ui/client/index.ts"],
    outDir: "dist/ui/client",
    onSuccess: async () => {
      await rewriteClient("./dist/ui/client/index.js");
      delayTypes();
      oldConsole.log(c.cyan("[UI]"), "Client", c.green("built"));
    },
  });
}

/**
 * Building UI Elements
 * - tailwind-merge is mocked, no exclude
 * - ui/client is external, and after built replaced with "bknd/client"
 */
async function buildUiElements() {
  await tsup.build({
    minify,
    sourcemap,
    watch: false,
    define,
    entry: ["src/ui/elements/index.ts"],
    outDir: "dist/ui/elements",
    external: [
      "ui/client",
      "bknd",
      /^bknd\/.*/,
      "wouter",
      "react",
      "react-dom",
      "react/jsx-runtime",
      "react/jsx-dev-runtime",
      "use-sync-external-store",
    ],
    metafile: true,
    platform: "browser",
    format: ["esm"],
    splitting: false,
    bundle: true,
    treeshake: true,
    loader: {
      ".svg": "dataurl",
    },
    esbuildOptions: (options) => {
      options.alias = {
        // not important for elements, mock to reduce bundle
        "tailwind-merge": "./src/ui/elements/mocks/tailwind-merge.ts",
      };
    },
    onSuccess: async () => {
      await rewriteClient("./dist/ui/elements/index.js");
      delayTypes();
      oldConsole.log(c.cyan("[UI]"), "Elements", c.green("built"));
    },
  });
}

/**
 * Building adapters
 */
function baseConfig(
  adapter: string,
  overrides: Partial<tsup.Options> = {},
): tsup.Options {
  return {
    minify,
    sourcemap,
    watch: false,
    entry: [`src/adapter/${adapter}/index.ts`],
    format: ["esm"],
    platform: "neutral",
    outDir: `dist/adapter/${adapter}`,
    metafile: true,
    splitting: false,
    removeNodeProtocol: false,
    onSuccess: async () => {
      delayTypes();
      oldConsole.log(c.cyan("[Adapter]"), adapter || "base", c.green("built"));
    },
    ...overrides,
    define: {
      ...define,
      ...overrides.define,
    },
    external: [
      /^cloudflare*/,
      /^@?hono.*?/,
      /^(bknd|react|next|node).*?/,
      /.*\.(html)$/,
      ...external,
      ...(Array.isArray(overrides.external) ? overrides.external : []),
    ],
  };
}

async function buildAdapters() {
  await Promise.all([
    // base adapter handles
    tsup.build({
      ...baseConfig(""),
      target: "esnext",
      platform: "neutral",
      entry: ["src/adapter/index.ts"],
      outDir: "dist/adapter",
      // only way to keep @vite-ignore comments
      minify: false,
    }),

    // specific adatpers
    tsup.build(baseConfig("react-router")),
    tsup.build(
      baseConfig("browser", {
        external: [/^sqlocal\/?.*?/, "wouter"],
      }),
    ),
    tsup.build(
      baseConfig("bun", {
        external: [/^bun\:.*/],
      }),
    ),
    tsup.build(baseConfig("astro")),
    tsup.build(baseConfig("aws")),
    tsup.build(
      baseConfig("cloudflare", {
        external: ["wrangler", "node:process"],
      }),
    ),
    tsup.build(
      baseConfig("cloudflare/proxy", {
        target: "esnext",
        entry: ["src/adapter/cloudflare/proxy.ts"],
        outDir: "dist/adapter/cloudflare",
        metafile: false,
        external: [/bknd/, "wrangler", "node:process"],
      }),
    ),

    tsup.build({
      ...baseConfig("vite"),
      platform: "node",
    }),

    tsup.build({
      ...baseConfig("nextjs"),
      platform: "node",
    }),

    tsup.build({
      ...baseConfig("tanstack-start"),
      platform: "node",
    }),

    tsup.build({
      ...baseConfig("sveltekit"),
      platform: "node",
    }),

    tsup.build({
      ...baseConfig("node"),
      platform: "node",
    }),

    tsup.build({
      ...baseConfig("sqlite/edge"),
      entry: ["src/adapter/sqlite/edge.ts"],
      outDir: "dist/adapter/sqlite",
      metafile: false,
    }),

    tsup.build({
      ...baseConfig("sqlite/node"),
      entry: ["src/adapter/sqlite/node.ts"],
      outDir: "dist/adapter/sqlite",
      platform: "node",
      metafile: false,
    }),

    tsup.build({
      ...baseConfig("sqlite/bun"),
      entry: ["src/adapter/sqlite/bun.ts"],
      outDir: "dist/adapter/sqlite",
      metafile: false,
      external: [/^bun\:.*/],
    }),

  ]);
}

async function buildAll() {
  await Promise.all([
    buildApi(),
    buildUi(),
    buildUiElements(),
    buildAdapters(),
  ]);
}

// initial build
await buildAll();

// custom watcher since tsup's watch is broken in 8.3.5+
if (watch) {
  oldConsole.log(c.cyan("[Watch]"), "watching for changes in src/...");

  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
  let isBuilding = false;

  const rebuild = async () => {
    if (isBuilding) return;
    isBuilding = true;
    oldConsole.log(c.cyan("[Watch]"), "rebuilding...");
    try {
      await buildAll();
      oldConsole.log(c.cyan("[Watch]"), c.green("done"));
    } catch (e) {
      oldConsole.warn(c.cyan("[Watch]"), c.red("build failed"), e);
    }
    isBuilding = false;
  };

  const debouncedRebuild = () => {
    if (debounceTimer) clearTimeout(debounceTimer);
    debounceTimer = setTimeout(rebuild, 100);
  };

  // watch src directory recursively
  fsWatch(
    join(import.meta.dir, "src"),
    { recursive: true },
    (event, filename) => {
      if (!filename) return;
      // ignore non-source files
      if (
        !filename.endsWith(".ts") &&
        !filename.endsWith(".tsx") &&
        !filename.endsWith(".css")
      )
        return;
      oldConsole.log(c.cyan("[Watch]"), c.dim(`${event}: ${filename}`));
      debouncedRebuild();
    },
  );

  // keep process alive
  await new Promise(() => {});
}