vite-elysia-forge 1.0.1 → 1.0.2

package/README.md

@@ -176,72 +176,139 @@ const app = new Elysia().use(
 
 ## 7. Production Deployment
 
-### 7.1 Build Configuration
+The CLI provides several build commands to bundle your frontend and Elysia backend for production.
 
-Update your `package.json` scripts:
+By default, the CLI looks for your API at `src/server/api.ts`. You can specify a custom path with the `--api` flag:
 
-Pick **one** build mode.
+```bash
+vite-elysia-forge build --api server/api.ts
+```
+
+### 7.1 Standard Build (`build`)
+
+Builds the frontend with Vite and bundles the Elysia server into a single JavaScript file.
+
+```bash
+vite-elysia-forge build
+```
+
+**What it does:**
+
+1. Runs `vite build` to compile your frontend to `dist/`
+2. Generates a production entry file that imports your API
+3. Bundles the server into `dist/server.js`
 
-Option A: build to `dist/server.js` (run with Bun):
+**package.json:**
 
 ```json
 {
   "scripts": {
-    "dev": "vite",
     "build": "vite-elysia-forge build",
     "start": "bun dist/server.js"
   }
 }
 ```
 
-Option B: build + compile to a standalone binary `dist/server`:
+### 7.2 Compiled Binary (`build-compile`)
+
+Builds everything and compiles the server into a **standalone executable** (no Bun runtime required on the target machine).
+
+```bash
+vite-elysia-forge build-compile
+```
+
+**What it does:**
+
+1. Performs the standard build
+2. Compiles `dist/server.js` into a native binary at `dist/server`
+
+**package.json:**
 
 ```json
 {
   "scripts": {
-    "dev": "vite",
     "build": "vite-elysia-forge build-compile",
     "start": "./dist/server"
   }
 }
 ```
 
-If your API is located elsewhere, specify the path:
+### 7.3 Separate Outputs (`--static` / `--server`)
+
+Build the frontend and backend to **separate directories** for independent deployment (e.g., static assets to a CDN, server to a VPS).
 
 ```bash
-vite-elysia-forge build src/my-api.ts
+vite-elysia-forge build --static dist --server .output
 ```
 
-### 7.2 Building for Production
+**Output structure:**
 
-Run the build command:
+```
+project/
+├── dist/           # Static assets (deploy to CDN)
+│   ├── index.html
+│   └── assets/
+└── .output/        # Server bundle (deploy to server)
+    └── server.js
+```
+
+**Use cases:**
+
+- Deploying static assets to Cloudflare Pages, Netlify, Vercel, etc.
+- Running the Elysia server on a separate VPS or Docker container
+- CI/CD pipelines that deploy frontend and backend independently
+
+**package.json:**
+
+```json
+{
+  "scripts": {
+    "build": "vite-elysia-forge build --static dist --server .output",
+    "start": "bun .output/server.js"
+  }
+}
+```
+
+Override the static assets path at runtime:
 
 ```bash
-bun run build
+STATIC_DIR=/path/to/static bun .output/server.js
 ```
 
-This command performs the following steps:
+### 7.4 Frontend Only (`build-static`)
 
-1. Runs `vite build` to compile your frontend to `dist/`
-2. Automatically generates a temporary entry file that imports your API from `src/server/api.ts`
-3. Bundles the server into a single file at `dist/server.js`
+Build only the frontend, skipping the server bundle.
 
-### 7.3 Building a Standalone Binary
+```bash
+vite-elysia-forge build-static
+```
+
+Useful for rebuilding just the frontend without touching the server.
 
-If you want a single executable (no Bun runtime required on the target machine), set your `build` script to `vite-elysia-forge build-compile` (Option B above) and run:
+### 7.5 Server Only (`build-server`)
+
+Build only the server bundle, skipping the Vite frontend build.
 
 ```bash
-bun run build
+vite-elysia-forge build-server --server .output --static dist
 ```
 
-This runs the normal build and then compiles `dist/server.js` into a standalone binary at `dist/server`.
+Useful when the frontend is already built or deployed separately.
+
+### 7.6 CLI Reference
 
-### 7.4 Starting the Production Server
+| Option           | Short | Default             | Description                                 |
+| :--------------- | :---: | :------------------ | :------------------------------------------ |
+| `--api <path>`   | `-a`  | `src/server/api.ts` | Path to API entry file                      |
+| `--static <dir>` | `-s`  | `dist`              | Output directory for static frontend assets |
+| `--server <dir>` | `-o`  | Same as `--static`  | Output directory for server bundle          |
+| `--skip-vite`    |       | `false`             | Skip the Vite frontend build                |
+| `--skip-server`  |       | `false`             | Skip the server build                       |
 
-Start the server with:
+**Example with custom API path:**
 
 ```bash
-bun start
+vite-elysia-forge build --api src/my-api.ts
 ```
 
 ## 8. Troubleshooting

package/dist/cli.d.ts

@@ -1,5 +1,39 @@
 #!/usr/bin/env bun
-declare function build(apiEntry?: string): Promise<void>;
-declare function buildCompile(apiEntry?: string): Promise<void>;
+/**
+ * Build options for customizing output directories.
+ */
+interface BuildOptions {
+    /**
+     * Path to the API entry file.
+     * @default "src/server/api.ts"
+     */
+    apiEntry?: string;
+    /**
+     * Output directory for the Vite/frontend static assets.
+     * @default "dist"
+     */
+    staticDir?: string;
+    /**
+     * Output directory for the Elysia server bundle.
+     * When set to a different value than staticDir, the server and static assets
+     * will be built to separate directories.
+     * @default "dist" (same as staticDir)
+     */
+    serverDir?: string;
+    /**
+     * Whether to skip the Vite frontend build.
+     * Useful when you only want to rebuild the server.
+     * @default false
+     */
+    skipVite?: boolean;
+    /**
+     * Whether to skip the server build.
+     * Useful when you only want to rebuild the frontend.
+     * @default false
+     */
+    skipServer?: boolean;
+}
+declare function build(options?: BuildOptions | string): Promise<void>;
+declare function buildCompile(options?: BuildOptions | string): Promise<void>;
 
-export { build, buildCompile };
+export { type BuildOptions, build, buildCompile };

package/dist/cli.js

@@ -1,11 +1,13 @@
 #!/usr/bin/env bun
-import {spawnSync}from'child_process';import {existsSync,mkdirSync,writeFileSync,unlinkSync,rmSync}from'fs';import {resolve,relative,sep}from'path';async function u(e="src/server/api.ts"){let r=resolve(process.cwd(),e);existsSync(r)||(console.error(`\u274C API entry file "${e}" not found.`),console.error('   By default, vite-elysia-forge looks for "src/server/api.ts".'),console.error("   If your API is located elsewhere, please specify the path:"),console.error("   $ vite-elysia-forge build <path-to-your-api-file>"),process.exit(1));let o=spawnSync("bun",["x","vite","build"],{stdio:"inherit",env:{...process.env,NODE_ENV:"production"}});o.status!==0&&(console.error("\u274C Vite build failed"),process.exit(o.status||1));let s=resolve(process.cwd(),".output");existsSync(s)||mkdirSync(s,{recursive:true});let i=resolve(s,".temp-prod.ts"),t=relative(s,r);t=t.split(sep).join("/"),t.startsWith(".")||(t="./"+t);let p=`
+import {spawnSync}from'child_process';import {existsSync,mkdirSync,writeFileSync,unlinkSync,rmSync}from'fs';import {resolve,relative,sep}from'path';async function v(r={}){let s=typeof r=="string"?{apiEntry:r}:r,t=s.apiEntry||"src/server/api.ts",e=s.staticDir||"dist",o=s.serverDir||e,u=s.skipVite||false,y=s.skipServer||false,b=e!==o,m=resolve(process.cwd(),t);if(!y&&!existsSync(m)&&(console.error(`\u274C API entry file "${t}" not found.`),console.error('   By default, vite-elysia-forge looks for "src/server/api.ts".'),console.error("   If your API is located elsewhere, please specify the path:"),console.error("   $ vite-elysia-forge build --api <path-to-your-api-file>"),process.exit(1)),!u){console.log(`\u{1F4E6} Building frontend to "${e}"...`);let i=spawnSync("bun",["x","vite","build","--outDir",e],{stdio:"inherit",env:{...process.env,NODE_ENV:"production"}});i.status!==0&&(console.error("\u274C Vite build failed"),process.exit(i.status||1)),console.log(`\u2705 Frontend built to "${e}"`);}if(y){console.log("\u23ED\uFE0F  Skipping server build (--skip-server)");return}let c=resolve(process.cwd(),".output");existsSync(c)||mkdirSync(c,{recursive:true});let d=resolve(c,".temp-prod.ts"),a=relative(c,m);a=a.split(sep).join("/"),a.startsWith(".")||(a="./"+a);let n;if(b){let i=resolve(process.cwd(),o),g=resolve(process.cwd(),e);n=relative(i,g),n.startsWith(".")||(n="./"+n),n=n.split(sep).join("/");}else n=".";let O=`
 import { startServer } from "vite-elysia-forge/production";
-import { api } from ${JSON.stringify(t)};
+import { api } from ${JSON.stringify(a)};
 
 startServer({
   api,
   port: process.env.PORT ? parseInt(process.env.PORT) : 3000,
-  distDir: "dist",
+  distDir: process.env.STATIC_DIR || ${JSON.stringify(n)},
 });
-`;writeFileSync(i,p);try{let n=await Bun.build({entrypoints:[i],outdir:"dist",target:"bun",minify:!0,naming:"server.js"});if(!n.success){console.error("\u274C Server build failed");for(let d of n.logs)console.error(d);process.exit(1);}}catch(n){console.error("\u274C Failed to build server. Ensure you are running this command with Bun."),console.error(n),process.exit(1);}finally{existsSync(i)&&unlinkSync(i),existsSync(s)&&rmSync(s,{recursive:true,force:true});}}async function h(e="src/server/api.ts"){await u(e);let r=spawnSync("bun",["build","--compile","dist/server.js","--outfile","dist/server"],{stdio:"inherit",env:{...process.env,NODE_ENV:"production"}});r.status!==0&&(console.error("\u274C Bun compile failed"),process.exit(r.status||1));}if(import.meta.main){let e=process.argv.slice(2),r=e[0];if(r==="build"){let o=e[1];u(o);}else if(r==="build-compile"){let o=e[1];h(o);}else console.log("Usage: vite-elysia-forge <command> [api-entry]"),console.log("Commands:"),console.log("  build          Build frontend + bundle server to dist/server.js"),console.log("  build-compile  Build and compile a standalone server binary to dist/server"),console.log(""),console.log("api-entry: Path to your API entry file (default: src/server/api.ts)");}export{u as build,h as buildCompile};
+`;writeFileSync(d,O);let h=resolve(process.cwd(),o);existsSync(h)||mkdirSync(h,{recursive:true}),console.log(`\u{1F4E6} Building server to "${o}"...`);try{let i=await Bun.build({entrypoints:[d],outdir:o,target:"bun",minify:!0,naming:"server.js"});if(!i.success){console.error("\u274C Server build failed");for(let g of i.logs)console.error(g);process.exit(1);}console.log(`\u2705 Server built to "${o}/server.js"`);}catch(i){console.error("\u274C Failed to build server. Ensure you are running this command with Bun."),console.error(i),process.exit(1);}finally{existsSync(d)&&unlinkSync(d),existsSync(c)&&rmSync(c,{recursive:true,force:true});}b&&(console.log(`
+\u{1F4C1} Output structure:`),console.log(`   Static assets: ${e}/`),console.log(`   Server bundle: ${o}/server.js`),console.log(`
+\u{1F4A1} To run: cd ${o} && bun server.js`),console.log("   Or set STATIC_DIR to override the static assets path"));}async function x(r={}){let s=typeof r=="string"?{apiEntry:r}:r,t=s.serverDir||s.staticDir||"dist";await v(s),console.log("\u{1F527} Compiling server to standalone binary...");let e=resolve(process.cwd(),t,"server.js"),o=resolve(process.cwd(),t,"server"),u=spawnSync("bun",["build","--compile",e,"--outfile",o],{stdio:"inherit",env:{...process.env,NODE_ENV:"production"}});u.status!==0&&(console.error("\u274C Bun compile failed"),process.exit(u.status||1)),console.log(`\u2705 Compiled standalone binary: ${t}/server`);}function f(r){let s={};for(let t=0;t<r.length;t++){let e=r[t],o=r[t+1];switch(e){case "--api":case "-a":o&&!o.startsWith("-")&&(s.apiEntry=o,t++);break;case "--static":case "-s":o&&!o.startsWith("-")&&(s.staticDir=o,t++);break;case "--server":case "-o":o&&!o.startsWith("-")&&(s.serverDir=o,t++);break;case "--skip-vite":s.skipVite=true;break;case "--skip-server":s.skipServer=true;break;default:e&&!e.startsWith("-")&&!s.apiEntry&&(s.apiEntry=e);}}return s}if(import.meta.main){let r=process.argv.slice(2),s=r[0],t=r.slice(1);if(s==="build"){let e=f(t);v(e);}else if(s==="build-compile"){let e=f(t);x(e);}else if(s==="build-static"){let e=f(t);e.skipServer=true,v(e);}else if(s==="build-server"){let e=f(t);e.skipVite=true,v(e);}else console.log("Usage: vite-elysia-forge <command> [options]"),console.log(""),console.log("Commands:"),console.log("  build          Build frontend + bundle server"),console.log("  build-compile  Build and compile a standalone server binary"),console.log("  build-static   Build only the frontend (skip server)"),console.log("  build-server   Build only the server (skip frontend)"),console.log(""),console.log("Options:"),console.log("  --api, -a <path>     Path to API entry file (default: src/server/api.ts)"),console.log("  --static, -s <dir>   Output directory for static assets (default: dist)"),console.log("  --server, -o <dir>   Output directory for server bundle (default: same as --static)"),console.log("  --skip-vite          Skip the Vite frontend build"),console.log("  --skip-server        Skip the server build"),console.log(""),console.log("Examples:"),console.log("  # Build everything to 'dist/' (default)"),console.log("  vite-elysia-forge build"),console.log(""),console.log("  # Build with separate output directories"),console.log("  vite-elysia-forge build --static dist --server .output"),console.log(""),console.log("  # Build only the frontend"),console.log("  vite-elysia-forge build-static --static public"),console.log(""),console.log("  # Build only the server to a separate folder"),console.log("  vite-elysia-forge build-server --server .output --static dist");}export{v as build,x as buildCompile};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-elysia-forge",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A Vite plugin to seamlessly integrate ElysiaJS for full-stack development with Bun runtime.",
   "type": "module",
   "main": "dist/index.cjs",