232 lines
9.3 KiB
TypeScript
232 lines
9.3 KiB
TypeScript
#!/usr/bin/env bun
|
|
/**
|
|
* @wrnexus/cli — the `wrnexus` command line.
|
|
*
|
|
* wrnexus dev [app-dir] [--port=3000] start the dev server (live reload)
|
|
* wrnexus build [app-dir] build a production server + assets
|
|
* wrnexus create <app-name> scaffold a new app
|
|
* wrnexus eject <name...> copy a Wire UI component into your app
|
|
* wrnexus db <migrate|rollback|status|new> database migrations
|
|
*/
|
|
|
|
import { join, resolve } from "node:path";
|
|
import { resolveProfile, loadEnv } from "@wrnexus/styles";
|
|
import { runDev } from "./dev.ts";
|
|
import { createApp } from "./create.ts";
|
|
import { currentCliVersion, notifyIfUpdateAvailable } from "./update-notifier.ts";
|
|
|
|
/**
|
|
* Resolve the active profile from `--profile=<name>` (or WRNEXUS_PROFILE / mode),
|
|
* publish it as WRNEXUS_PROFILE (so config loaders + the dev child pick it up),
|
|
* and load its `.env` cascade into process.env. Returns the profile name.
|
|
*/
|
|
function bootstrapProfile(
|
|
appRoot: string,
|
|
mode: "development" | "production",
|
|
args: string[],
|
|
): string {
|
|
const flag = args.find((a) => a.startsWith("--profile="));
|
|
const profile = resolveProfile({ explicit: flag?.split("=")[1], mode });
|
|
process.env.WRNEXUS_PROFILE = profile;
|
|
const loaded = loadEnv(resolve(appRoot), profile);
|
|
const count = Object.keys(loaded).length;
|
|
console.log(` ▸ profile: ${profile}${count ? ` (${count} env vars loaded)` : ""}`);
|
|
return profile;
|
|
}
|
|
|
|
function help(): void {
|
|
console.log(`wrnexus — WrNexus CLI
|
|
|
|
Usage:
|
|
wrnexus dev [app-dir] [--port=3000] [--host=::]
|
|
Start the development server (live reload)
|
|
wrnexus build [app-dir] Build a production server bundle + assets
|
|
wrnexus create <app-name> Scaffold a new app
|
|
wrnexus workspace <name> Scaffold a monorepo (apps/* + shared packages/*)
|
|
wrnexus workspace add <name> [--domain=name.localhost]
|
|
Add an app to the current workspace
|
|
wrnexus gateway [--port=3000] Serve every workspace app behind one port, routed by domain
|
|
wrnexus production [workspace-dir] Build, migrate, and serve the complete production workspace
|
|
wrnexus <environment> [workspace-dir] Run a configured workspace environment (development/staging/custom)
|
|
wrnexus generate <type> <name> Scaffold a page | component | api | schema
|
|
wrnexus generate routes | docker | mobile
|
|
Generate routes or scaffold deployment targets
|
|
wrnexus mobile add <package...> Install Capacitor or Expo native packages
|
|
wrnexus mobile compile Compile .wrn pages into native Expo routes
|
|
wrnexus native list List cross-platform native capabilities
|
|
wrnexus native add <capability...> Install capability packages for the configured mobile mode
|
|
wrnexus eject <name...> Copy a Wire UI component into app/components
|
|
wrnexus update [dir] [--latest] Upgrade deps, migrate project files, and verify the app
|
|
wrnexus db <cmd> Migrations: migrate | rollback | status | seed | generate | new
|
|
wrnexus test [app-dir] [--watch] Run the app's tests (bun test, 'test' profile)
|
|
wrnexus profiles [app-dir] List config profiles (dev/prod/uat/…) and their env files
|
|
wrnexus doctor [app-dir] Check project structure, runtime, mobile config, and next fixes
|
|
|
|
Profiles: pass --profile=<name> to dev/build/db (or set WRNEXUS_PROFILE) to load
|
|
that profile's .env cascade and config overrides. e.g. wrnexus dev --profile=uat
|
|
|
|
Update options: --dry-run previews changes; --no-verify skips post-update check/build.
|
|
`);
|
|
}
|
|
|
|
async function main(): Promise<void> {
|
|
const [command, ...rest] = process.argv.slice(2);
|
|
|
|
notifyIfUpdateAvailable(currentCliVersion(), command);
|
|
|
|
switch (command) {
|
|
case "dev": {
|
|
const appRoot = rest.find((a) => !a.startsWith("--")) ?? ".";
|
|
const portArg = rest.find((a) => a.startsWith("--port="));
|
|
const hostArg = rest.find((a) => a.startsWith("--host="));
|
|
const port = portArg ? Number(portArg.split("=")[1]) : 3000;
|
|
const host = hostArg?.split("=")[1] || "::";
|
|
bootstrapProfile(appRoot, "development", rest);
|
|
runDev(appRoot, port, host);
|
|
break;
|
|
}
|
|
case "build": {
|
|
const appRoot = rest.find((a) => !a.startsWith("--")) ?? ".";
|
|
bootstrapProfile(appRoot, "production", rest);
|
|
const { runBuild } = await import("./build.ts");
|
|
await runBuild(appRoot);
|
|
break;
|
|
}
|
|
case "create":
|
|
createApp(rest[0] ?? "");
|
|
break;
|
|
case "workspace": {
|
|
const { addWorkspaceApp, createWorkspace } = await import("./workspace.ts");
|
|
if (rest[0] === "add") {
|
|
await addWorkspaceApp(".", rest[1] ?? "", rest.slice(2));
|
|
} else {
|
|
createWorkspace(rest.find((a) => !a.startsWith("--")) ?? "");
|
|
}
|
|
break;
|
|
}
|
|
case "gateway": {
|
|
const appRoot = rest.find((a) => !a.startsWith("--")) ?? ".";
|
|
const { runGateway } = await import("./workspace.ts");
|
|
await runGateway(appRoot, rest);
|
|
break;
|
|
}
|
|
case "production": {
|
|
const workspaceRoot = rest.find((a) => !a.startsWith("--")) ?? ".";
|
|
const { runProduction } = await import("./workspace.ts");
|
|
await runProduction(workspaceRoot, rest);
|
|
break;
|
|
}
|
|
case "generate":
|
|
case "g": {
|
|
if (rest[0] === "routes") {
|
|
const { regenerateRoutes } = await import("./routes.ts");
|
|
const n = regenerateRoutes(join(process.cwd(), "app"));
|
|
console.log(`✓ Generated app/routes.gen.ts (${n} routes)`);
|
|
break;
|
|
}
|
|
if (rest[0] === "docker") {
|
|
const { generateDocker } = await import("./docker.ts");
|
|
generateDocker(process.cwd());
|
|
break;
|
|
}
|
|
if (rest[0] === "mobile") {
|
|
const { generateMobile, mobileOptions } = await import("./mobile.ts");
|
|
await generateMobile(process.cwd(), mobileOptions(rest.slice(1)));
|
|
break;
|
|
}
|
|
const { runGenerate } = await import("./generate.ts");
|
|
runGenerate(".", rest[0], rest[1]);
|
|
break;
|
|
}
|
|
case "eject": {
|
|
const { runEject } = await import("./eject.ts");
|
|
const args = rest.filter((a) => !a.startsWith("--"));
|
|
// First arg may be an app dir; treat known component names as names.
|
|
runEject(".", args);
|
|
break;
|
|
}
|
|
case "mobile": {
|
|
const { runMobileCommand } = await import("./mobile-command.ts");
|
|
await runMobileCommand(".", rest[0], rest.slice(1));
|
|
break;
|
|
}
|
|
case "native": {
|
|
const { runNativeCommand } = await import("./native-command.ts");
|
|
await runNativeCommand(".", rest[0], rest.slice(1));
|
|
break;
|
|
}
|
|
case "update":
|
|
case "upgrade": {
|
|
const dir = rest.find((a) => !a.startsWith("--")) ?? ".";
|
|
const { runUpdate } = await import("./update.ts");
|
|
await runUpdate(dir, rest);
|
|
break;
|
|
}
|
|
case "db": {
|
|
bootstrapProfile(".", "development", rest);
|
|
const { runDbCommand } = await import("./db.ts");
|
|
const [sub, ...dbArgs] = rest.filter((a) => !a.startsWith("--profile="));
|
|
await runDbCommand(".", sub, dbArgs);
|
|
break;
|
|
}
|
|
case "profiles": {
|
|
const { listProfiles } = await import("./profiles.ts");
|
|
await listProfiles(rest.find((a) => !a.startsWith("--")) ?? ".");
|
|
break;
|
|
}
|
|
case "doctor": {
|
|
const { runDoctor } = await import("./doctor.ts");
|
|
const healthy = runDoctor(rest.find((a) => !a.startsWith("--")) ?? ".");
|
|
if (!healthy) process.exitCode = 1;
|
|
break;
|
|
}
|
|
case "test": {
|
|
const appRoot = rest.find((a) => !a.startsWith("--")) ?? ".";
|
|
const flag = rest.find((a) => a.startsWith("--profile="));
|
|
// Tests default to the `test` profile (config + .env.test), unless overridden.
|
|
process.env.WRNEXUS_PROFILE = resolveProfile({ explicit: flag?.split("=")[1] ?? "test" });
|
|
loadEnv(resolve(appRoot), process.env.WRNEXUS_PROFILE);
|
|
const { runTests } = await import("./test.ts");
|
|
runTests(appRoot, rest);
|
|
break;
|
|
}
|
|
case undefined:
|
|
case "help":
|
|
case "--help":
|
|
case "-h":
|
|
help();
|
|
break;
|
|
default: {
|
|
const { loadWorkspaceConfig, runGateway, runProduction } = await import("./workspace.ts");
|
|
const workspaceRoot = rest.find((a) => !a.startsWith("--")) ?? ".";
|
|
try {
|
|
const workspace = await loadWorkspaceConfig(resolve(workspaceRoot));
|
|
const knownEnvironments = new Set([
|
|
"development",
|
|
"production",
|
|
workspace.defaultEnvironment,
|
|
...Object.keys(workspace.environments ?? {}),
|
|
]);
|
|
if (!knownEnvironments.has(command)) throw new Error("unknown-environment-command");
|
|
const environmentArgs = rest.filter((arg) => arg !== workspaceRoot);
|
|
environmentArgs.push(`--environment=${command}`);
|
|
if (command === "development") {
|
|
await runGateway(workspaceRoot, environmentArgs);
|
|
} else {
|
|
await runProduction(workspaceRoot, environmentArgs);
|
|
}
|
|
} catch (error) {
|
|
if (error instanceof Error && error.message !== "unknown-environment-command") throw error;
|
|
console.error(`Unknown command or workspace environment: ${command}\n`);
|
|
help();
|
|
process.exit(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
main().catch((err) => {
|
|
console.error(err);
|
|
process.exit(1);
|
|
});
|