create-nexwire 4.0.0

package/hono/src/framework/maker-cli/deploy/index.mjs

@@ -0,0 +1,91 @@
+import {
+  createDeploy,
+  importDumpLocal,
+  importDumpRemote,
+  initDeployWorkflow,
+  initRemoteDeployWorkflow,
+  runDeployWorkflow,
+  runPromoteWorkflow,
+  runRemoteWorkflow
+} from "./core.mjs";
+
+export const deployCommands = new Set([
+  "deploy:init",
+  "deploy:workflow",
+  "deploy:workflow:remote",
+  "deploy:workflow:promote",
+  "deploy:db:import",
+  "deploy:db:import:remote"
+]);
+
+/** Register deploy:* subcommands on the CLI program. */
+export function registerDeployCommands(program, rawArgs) {
+  const flags = rawArgs.slice(1);
+  program
+    .command("deploy:init")
+    .description("Generate deploy scaffolding (app + server) and workflow configs")
+    .option("--app-only", "Generate app deploy files only")
+    .option("--server-only", "Generate server infra files only")
+    .option("--dev", "Server infra in dev mode (exposed Redis port)")
+    .option("--force", "Overwrite existing deploy folder")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--pm <name>", "Package manager for node runtime: npm, pnpm, yarn", "npm")
+    .allowUnknownOption(true)
+    .action(async () => {
+      await createDeploy(flags);
+      await initDeployWorkflow();
+      await initRemoteDeployWorkflow();
+    });
+  program
+    .command("deploy:db:import")
+    .description("Import SQL dump into local Docker container (auto-detects MySQL or PostgreSQL)")
+    .option("--file <path>", "SQL dump file path", "deploy/nexwire.sql")
+    .option("--database <name>", "Target database name", "nexwire")
+    .option("--container <name>", "DB container name (mysql-global or postgres-global)")
+    .option("--user <name>", "DB user (defaults to server .env or DATABASE_URL)")
+    .option("--password <password>", "DB password (falls back to deploy/server/.env, then deploy/.env)")
+    .option("--no-drop", "PostgreSQL: keep existing database instead of dropping it for a clean restore")
+    .allowUnknownOption(true)
+    .action(async () => importDumpLocal(flags));
+  program
+    .command("deploy:db:import:remote")
+    .description("Import SQL dump into remote Docker container via SSH (auto-detects MySQL or PostgreSQL)")
+    .option("--config <path>", "Remote workflow config path", "deploy/workflow.remote.json")
+    .option("--file <path>", "SQL dump file path", "deploy/nexwire.sql")
+    .option("--database <name>", "Target database name", "nexwire")
+    .option("--container <name>", "DB container name (mysql-global or postgres-global)")
+    .option("--user <name>", "DB user (defaults to server .env or config)")
+    .option("--password <password>", "DB password (falls back to remote deploy/server/.env)")
+    .option("--dry-run", "Print commands without executing")
+    .allowUnknownOption(true)
+    .action(async () => importDumpRemote(flags));
+  program
+    .command("deploy:workflow")
+    .description("Run local CI/CD workflow (Docker Desktop) from config file or flags")
+    .option("--config <path>", "Workflow config path")
+    .option("--server-only", "Run server infra step only")
+    .option("--app-only", "Run app deploy step only")
+    .option("--refresh", "Regenerate deploy files before running")
+    .option("--dry-run", "Print steps without executing")
+    .allowUnknownOption(true)
+    .action(async () => runDeployWorkflow(flags));
+  program
+    .command("deploy:workflow:remote")
+    .description("Upload full repo and deploy on remote Docker host")
+    .option("--config <path>", "Remote workflow config path", "deploy/workflow.remote.json")
+    .option("--server-only", "Run server infra step only")
+    .option("--app-only", "Run app deploy step only")
+    .option("--dry-run", "Print commands without executing")
+    .allowUnknownOption(true)
+    .action(async () => runRemoteWorkflow(flags));
+  program
+    .command("deploy:workflow:promote")
+    .description("Run local workflow then remote workflow")
+    .option("--config <path>", "Workflow config path")
+    .option("--server-only", "Run server infra step only")
+    .option("--app-only", "Run app deploy step only")
+    .option("--refresh", "Regenerate deploy files before running")
+    .option("--dry-run", "Print steps without executing")
+    .allowUnknownOption(true)
+    .action(async () => runPromoteWorkflow(flags));
+}

package/hono/src/framework/maker-cli/index.mjs

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { config } from "dotenv";
+import { registerDbCommands } from "./db/index.mjs";
+import { registerMiddlewareCommands } from "./middleware/index.mjs";
+import { registerModuleCommands } from "./module/index.mjs";
+import { registerRuntimeCommands } from "./runtime/index.mjs";
+import { makerCommandPrefix, showHelp } from "./utils/help.mjs";
+
+const args = process.argv.slice(2);
+const [command] = args;
+
+let deployCommands = new Set();
+let registerDeployCommands = () => {};
+
+try {
+  const deploy = await import("./deploy/index.mjs");
+  deployCommands = deploy.deployCommands;
+  registerDeployCommands = deploy.registerDeployCommands;
+} catch {
+  /* deploy module not available until user runs deploy:init */
+}
+
+if (!deployCommands.has(command || "")) {
+  config({ path: ".env", quiet: true });
+}
+
+try {
+  const program = new Command();
+  const namePrefix = makerCommandPrefix();
+  program
+    .name(namePrefix ? `${namePrefix} maker` : "maker")
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
+    .helpOption("-h, --help")
+    .addHelpText("beforeAll", "nexwire maker\n");
+
+  registerMiddlewareCommands(program, args);
+  registerModuleCommands(program, args);
+  registerDeployCommands(program, args);
+  registerDbCommands(program, args);
+  registerRuntimeCommands(program, args);
+
+  if (!command) {
+    showHelp(program);
+  } else {
+    await program.parseAsync(args, { from: "user" });
+  }
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+}

package/hono/src/framework/maker-cli/middleware/core.mjs

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { hasFlag } from "../utils/flags.mjs";
+import { assertName, pascal } from "../utils/naming.mjs";
+
+const stubsRoot = path.resolve(import.meta.dirname, "../stubs");
+
+/** Read a stub file and replace {{key}} placeholders, removing unfilled ones. */
+async function stub(name, values = {}) {
+  let content = await fs.readFile(path.join(stubsRoot, name), "utf8");
+  for (const [key, value] of Object.entries(values)) {
+    content = content.replaceAll(`{{${key}}}`, String(value));
+  }
+  return content.replace(/\{\{[A-Z0-9_]+\}\}/g, "");
+}
+
+/** Convert a name to camelCase (e.g. "rate-limit" -> "rateLimit"). */
+function camelCase(input) {
+  const p = pascal(input);
+  return p.charAt(0).toLowerCase() + p.slice(1);
+}
+
+/** Generate a middleware file in src/middlewares. */
+export async function makeMiddleware(rawName, flags = []) {
+  const name = assertName(rawName, "Middleware name");
+  const camel = camelCase(name);
+  const dryRun = hasFlag(flags, "--dry-run");
+  const force = hasFlag(flags, "--force") || hasFlag(flags, "--yes");
+
+  const filePath = path.resolve(process.cwd(), "src/middlewares", `${name}-middleware.ts`);
+  if (dryRun) return;
+
+  let exists = false;
+  try {
+    await fs.access(filePath);
+    exists = true;
+  } catch {}
+  if (exists && !force) {
+    throw new Error(`Middleware already exists: ${path.relative(process.cwd(), filePath)}. Re-run with --force to overwrite.`);
+  }
+
+  const content = await stub("middleware/name.ts.stub", { name, camel });
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, content);
+  console.log(`Middleware ready: ${path.relative(process.cwd(), filePath)}`);
+  console.log(`Apply it to a route group: group(${camel}Middleware)`);
+}

package/hono/src/framework/maker-cli/middleware/index.mjs

@@ -0,0 +1,12 @@
+import { makeMiddleware } from "./core.mjs";
+
+/** Register middleware:* subcommands on the CLI program. */
+export function registerMiddlewareCommands(program, rawArgs) {
+  program
+    .command("middleware:make <name>")
+    .description("Generate a middleware file in src/middlewares")
+    .option("--force", "Overwrite existing middleware file")
+    .option("--dry-run", "Print what would be created without executing")
+    .allowUnknownOption(true)
+    .action(async (name) => makeMiddleware(name, rawArgs.filter((arg) => arg.startsWith("--"))));
+}