@donkeylabs/cli 2.0.14 → 2.0.16

package/src/commands/deploy-enhanced.ts

@@ -0,0 +1,354 @@
+// packages/cli/src/commands/deploy-enhanced.ts
+/**
+ * Enhanced deploy command with history, versioning, and rollbacks
+ */
+
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import pc from "picocolors";
+import { createDeploymentManager } from "../deployment/manager";
+
+interface DeployOptions {
+  platform: "vercel" | "cloudflare" | "aws" | "vps";
+  environment: "production" | "staging" | "development";
+  version?: string;
+  versionBump?: "major" | "minor" | "patch";
+  skipBuild?: boolean;
+}
+
+export async function deployEnhancedCommand(args: string[]) {
+  const platform = args[0] as DeployOptions["platform"];
+  
+  if (!platform) {
+    console.error(pc.red("❌ Platform required"));
+    console.log(pc.gray("Usage: donkeylabs deploy <platform>"));
+    console.log(pc.gray("Platforms: vercel, cloudflare, aws, vps"));
+    process.exit(1);
+  }
+
+  const options = await promptForOptions(platform);
+  const manager = createDeploymentManager(process.cwd(), {
+    projectName: getProjectName(),
+    platform: options.platform,
+    environment: options.environment,
+    versionStrategy: "semver",
+  });
+
+  // Determine version
+  const version = options.version || manager.getNextVersion(options.versionBump);
+  
+  console.log(pc.cyan(pc.bold(`\n🚀 Deploying v${version} to ${platform}\n`)));
+
+  // Pre-deployment checks
+  if (!(await runPreDeployChecks(options))) {
+    process.exit(1);
+  }
+
+  // Build
+  if (!options.skipBuild) {
+    console.log(pc.blue("📦 Building..."));
+    try {
+      execSync("bun run build", { stdio: "inherit" });
+    } catch {
+      await manager.recordDeployment(version, platform, "failed");
+      console.error(pc.red("❌ Build failed"));
+      process.exit(1);
+    }
+  }
+
+  // Deploy
+  let url: string | undefined;
+  try {
+    url = await deployToPlatform(options, version);
+    console.log(pc.green(`\n✅ Deployed successfully!`));
+    console.log(pc.gray(`URL: ${url}`));
+  } catch (error) {
+    await manager.recordDeployment(version, platform, "failed");
+    console.error(pc.red("\n❌ Deployment failed"));
+    process.exit(1);
+  }
+
+  // Record successful deployment
+  const deployment = await manager.recordDeployment(version, platform, "success", url, {
+    duration: Date.now(), // Would track actual duration
+  });
+
+  // Show deployment info
+  console.log(pc.cyan(`\n📊 Deployment recorded`));
+  console.log(pc.gray(`ID: ${deployment.id}`));
+  console.log(pc.gray(`Version: ${deployment.version}`));
+  console.log(pc.gray(`Git: ${deployment.gitSha} - ${deployment.gitMessage}`));
+  
+  // Update package.json version
+  updatePackageVersion(version);
+  
+  console.log(pc.green(`\n🎉 Done!`));
+}
+
+async function promptForOptions(platform: string): Promise<DeployOptions> {
+  const prompts = await import("prompts");
+  
+  const environment = await prompts.default({
+    type: "select",
+    name: "value",
+    message: "Environment:",
+    choices: [
+      { title: "Production", value: "production" },
+      { title: "Staging", value: "staging" },
+      { title: "Preview", value: "preview" },
+    ],
+    initial: 0,
+  }).then((r: any) => r.value);
+
+  const versionBump = await prompts.default({
+    type: "select",
+    name: "value",
+    message: "Version bump:",
+    choices: [
+      { title: "patch (bug fixes)", value: "patch" },
+      { title: "minor (new features)", value: "minor" },
+      { title: "major (breaking changes)", value: "major" },
+      { title: "custom version", value: "custom" },
+    ],
+    initial: 0,
+  }).then((r: any) => r.value);
+
+  let version: string | undefined;
+  if (versionBump === "custom") {
+    version = await prompts.default({
+      type: "text",
+      name: "value",
+      message: "Version:",
+      initial: "1.0.0",
+    }).then((r: any) => r.value);
+  }
+
+  return {
+    platform: platform as DeployOptions["platform"],
+    environment,
+    version,
+    versionBump: versionBump === "custom" ? undefined : versionBump,
+  };
+}
+
+async function runPreDeployChecks(options: DeployOptions): Promise<boolean> {
+  const checks = [
+    { name: "Git clean", fn: () => checkGitClean() },
+    { name: "Tests pass", fn: () => checkTests() },
+    { name: "TypeScript compiles", fn: () => checkTypescript() },
+    { name: "Environment variables", fn: () => checkEnvVars(options.platform) },
+  ];
+
+  console.log(pc.blue("\n🔍 Pre-deployment checks:\n"));
+  
+  for (const check of checks) {
+    process.stdout.write(`  ${check.name}... `);
+    try {
+      await check.fn();
+      console.log(pc.green("✓"));
+    } catch (error) {
+      console.log(pc.red("✗"));
+      console.error(pc.red(`  ${error}`));
+      return false;
+    }
+  }
+
+  console.log();
+  return true;
+}
+
+async function deployToPlatform(options: DeployOptions, version: string): Promise<string> {
+  switch (options.platform) {
+    case "vercel":
+      return deployToVercel(options, version);
+    case "cloudflare":
+      return deployToCloudflare(options, version);
+    case "aws":
+      return deployToAWS(options, version);
+    case "vps":
+      return deployToVPS(options, version);
+    default:
+      throw new Error(`Unknown platform: ${options.platform}`);
+  }
+}
+
+async function deployToVercel(options: DeployOptions, version: string): Promise<string> {
+  // Ensure vercel.json exists
+  setupVercelConfig();
+  
+  const args = options.environment === "production" ? ["--prod"] : [];
+  const output = execSync(`vercel ${args.join(" ")}`, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  
+  // Extract URL from output
+  const urlMatch = output.match(/https:\/\/[^\s]+/);
+  return urlMatch ? urlMatch[0] : "";
+}
+
+async function deployToCloudflare(options: DeployOptions, version: string): Promise<string> {
+  // Ensure wrangler.toml exists
+  setupWranglerConfig(version);
+  
+  execSync("wrangler deploy", { stdio: "inherit" });
+  
+  // Get deployment URL
+  const output = execSync("wrangler deployment list --limit 1", {
+    encoding: "utf-8",
+  });
+  
+  const urlMatch = output.match(/https:\/\/[^\s]+/);
+  return urlMatch ? urlMatch[0] : "";
+}
+
+async function deployToAWS(options: DeployOptions, version: string): Promise<string> {
+  // SAM or Serverless Framework deployment
+  execSync("sam deploy", { stdio: "inherit" });
+  
+  // Get API Gateway URL
+  const output = execSync("sam list stack-outputs", {
+    encoding: "utf-8",
+  });
+  
+  const urlMatch = output.match(/https:\/\/[^\s]+\.amazonaws\.com/);
+  return urlMatch ? urlMatch[0] : "";
+}
+
+async function deployToVPS(options: DeployOptions, version: string): Promise<string> {
+  // Docker deployment to VPS
+  execSync("docker-compose build", { stdio: "inherit" });
+  execSync("docker-compose up -d", { stdio: "inherit" });
+  
+  return "http://your-vps-ip:3000"; // Would get actual IP
+}
+
+// Helper functions
+function getProjectName(): string {
+  const pkgPath = join(process.cwd(), "package.json");
+  if (!existsSync(pkgPath)) return "unknown";
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  return pkg.name;
+}
+
+function checkGitClean(): void {
+  const status = execSync("git status --porcelain", { encoding: "utf-8" });
+  if (status.trim()) {
+    throw new Error("Uncommitted changes. Commit or stash first.");
+  }
+}
+
+function checkTests(): void {
+  try {
+    execSync("bun test", { stdio: "pipe" });
+  } catch {
+    throw new Error("Tests failed");
+  }
+}
+
+function checkTypescript(): void {
+  try {
+    execSync("bun --bun tsc --noEmit", { stdio: "pipe" });
+  } catch {
+    throw new Error("TypeScript errors");
+  }
+}
+
+function checkEnvVars(platform: string): void {
+  // Platform-specific env checks
+  const envPath = join(process.cwd(), ".env.local");
+  if (!existsSync(envPath)) {
+    throw new Error(".env.local not found");
+  }
+}
+
+function setupVercelConfig(): void {
+  // Create vercel.json if not exists
+}
+
+function setupWranglerConfig(version: string): void {
+  // Create wrangler.toml if not exists
+}
+
+function updatePackageVersion(version: string): void {
+  const pkgPath = join(process.cwd(), "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  pkg.version = version;
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+}
+
+// Additional CLI commands
+export async function deployHistoryCommand(args: string[]) {
+  const manager = createDeploymentManager(process.cwd(), {
+    projectName: getProjectName(),
+    platform: "vercel",
+    environment: "production",
+    versionStrategy: "semver",
+  });
+
+  const history = manager.listDeployments({ limit: 10 });
+  
+  console.log(pc.cyan(pc.bold("\n📜 Deployment History\n")));
+  
+  for (const deployment of history) {
+    const statusIcon = deployment.status === "success" ? pc.green("✓") : 
+                      deployment.status === "failed" ? pc.red("✗") : pc.yellow("↺");
+    
+    console.log(`${statusIcon} ${pc.bold(deployment.version)} ${pc.gray(deployment.platform)}`);
+    console.log(`   ${deployment.gitSha} - ${deployment.gitMessage}`);
+    console.log(`   ${deployment.timestamp}${deployment.url ? ` - ${deployment.url}` : ""}`);
+    console.log();
+  }
+}
+
+export async function deployRollbackCommand(args: string[]) {
+  const version = args[0];
+  
+  const manager = createDeploymentManager(process.cwd(), {
+    projectName: getProjectName(),
+    platform: "vercel",
+    environment: "production",
+    versionStrategy: "semver",
+  });
+
+  console.log(pc.yellow(pc.bold("\n⚠️  Rollback\n")));
+  
+  if (version) {
+    console.log(`Rolling back to version: ${version}`);
+  } else {
+    console.log("Rolling back to previous version");
+  }
+
+  try {
+    const deployment = await manager.rollback(version);
+    if (deployment) {
+      console.log(pc.green(`\n✅ Rolled back to v${deployment.version}`));
+    }
+  } catch (error: any) {
+    console.error(pc.red(`\n❌ Rollback failed: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+export async function deployStatsCommand() {
+  const manager = createDeploymentManager(process.cwd(), {
+    projectName: getProjectName(),
+    platform: "vercel",
+    environment: "production",
+    versionStrategy: "semver",
+  });
+
+  const stats = manager.getStats();
+  
+  console.log(pc.cyan(pc.bold("\n📊 Deployment Statistics\n")));
+  console.log(`Total deployments: ${stats.totalDeployments}`);
+  console.log(`Successful: ${pc.green(stats.successfulDeployments.toString())}`);
+  console.log(`Failed: ${pc.red(stats.failedDeployments.toString())}`);
+  console.log(`Rollbacks: ${pc.yellow(stats.rollbackCount.toString())}`);
+  
+  console.log(pc.cyan("\nBy Platform:"));
+  for (const [platform, count] of Object.entries(stats.deploymentsByPlatform)) {
+    console.log(`  ${platform}: ${count}`);
+  }
+}

package/src/commands/deploy.ts

@@ -0,0 +1,204 @@
+// packages/cli/src/commands/deploy.ts
+/**
+ * Deploy command for serverless platforms
+ * Currently supports Vercel
+ */
+
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import pc from "picocolors";
+
+export async function deployCommand(args: string[]) {
+  const platform = args[0] || "vercel";
+
+  console.log(pc.cyan(pc.bold(`\n🚀 Deploy to ${platform}\n`)));
+
+  switch (platform) {
+    case "vercel":
+      await deployToVercel();
+      break;
+    case "help":
+      showHelp();
+      break;
+    default:
+      console.error(pc.red(`❌ Unknown platform: ${platform}`));
+      console.log(pc.yellow("Supported platforms: vercel"));
+      process.exit(1);
+  }
+}
+
+async function deployToVercel() {
+  // Check if vercel CLI is installed
+  try {
+    execSync("which vercel", { stdio: "pipe" });
+  } catch {
+    console.log(pc.yellow("⚠️  Vercel CLI not found. Installing..."));
+    try {
+      execSync("npm install -g vercel", { stdio: "inherit" });
+    } catch {
+      console.error(pc.red("❌ Failed to install Vercel CLI"));
+      console.log(pc.gray("Install manually: npm install -g vercel"));
+      process.exit(1);
+    }
+  }
+
+  // Check project structure
+  const projectDir = process.cwd();
+
+  if (!existsSync(join(projectDir, "vercel.json"))) {
+    console.log(pc.yellow("⚠️  No vercel.json found. Creating serverless configuration..."));
+    await setupVercelProject(projectDir);
+  }
+
+  // Check for required environment variables
+  const envFile = join(projectDir, ".env.local");
+  if (existsSync(envFile)) {
+    const envContent = readFileSync(envFile, "utf-8");
+    if (!envContent.includes("DATABASE_URL")) {
+      console.error(pc.red("❌ DATABASE_URL not found in .env.local"));
+      console.log(pc.yellow("Serverless requires PostgreSQL. SQLite won't work."));
+      console.log(pc.gray("Set up a PostgreSQL database and add DATABASE_URL to .env.local"));
+      process.exit(1);
+    }
+  }
+
+  // Build the project
+  console.log(pc.blue("📦 Building project..."));
+  try {
+    execSync("bun run build", { stdio: "inherit" });
+  } catch {
+    console.error(pc.red("❌ Build failed"));
+    process.exit(1);
+  }
+
+  // Deploy
+  console.log(pc.blue("\n🚀 Deploying to Vercel...\n"));
+  try {
+    execSync("vercel --prod", { stdio: "inherit" });
+  } catch {
+    console.error(pc.red("❌ Deployment failed"));
+    process.exit(1);
+  }
+
+  console.log(pc.green("\n✅ Deployment complete!"));
+  console.log(pc.gray("\nYour API is live at the URL shown above."));
+  console.log(pc.gray("Test it: curl https://your-app.vercel.app/api.health"));
+}
+
+async function setupVercelProject(projectDir: string) {
+  // Create vercel.json
+  const vercelConfig = {
+    version: 2,
+    builds: [
+      {
+        src: "api/index.ts",
+        use: "@vercel/node",
+        config: {
+          includeFiles: "dist/**",
+        },
+      },
+    ],
+    routes: [
+      {
+        src: "/api/(.*)",
+        dest: "/api/index.ts",
+      },
+      {
+        src: "/(.*)",
+        dest: "/api/index.ts",
+      },
+    ],
+    env: {
+      NODE_ENV: "production",
+    },
+  };
+
+  writeFileSync(
+    join(projectDir, "vercel.json"),
+    JSON.stringify(vercelConfig, null, 2)
+  );
+
+  // Create api/index.ts if it doesn't exist
+  const apiDir = join(projectDir, "api");
+  if (!existsSync(apiDir)) {
+    require("fs").mkdirSync(apiDir, { recursive: true });
+  }
+
+  if (!existsSync(join(apiDir, "index.ts"))) {
+    const handlerContent = `import { createVercelHandler } from "@donkeylabs/adapter-serverless";
+import { createServer } from "../src/server";
+
+// Create server instance
+const server = createServer();
+
+// Export handler for Vercel
+export default createVercelHandler(() => server);
+`;
+    writeFileSync(join(apiDir, "index.ts"), handlerContent);
+  }
+
+  // Create src/server/index.ts that exports createServer
+  const serverDir = join(projectDir, "src", "server");
+  if (!existsSync(join(serverDir, "index.ts"))) {
+    const serverContent = `import { AppServer } from "@donkeylabs/server";
+import { db } from "./db";
+
+export function createServer() {
+  return new AppServer({
+    db,
+    logger: { level: "info" },
+  });
+}
+`;
+    writeFileSync(join(serverDir, "index.ts"), serverContent);
+  }
+
+  // Update package.json with serverless adapter
+  const pkgPath = join(projectDir, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+
+  if (!pkg.dependencies["@donkeylabs/adapter-serverless"]) {
+    pkg.dependencies["@donkeylabs/adapter-serverless"] = "latest";
+  }
+
+  if (!pkg.dependencies.pg) {
+    pkg.dependencies.pg = "^8.11.0";
+  }
+
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+
+  console.log(pc.green("✅ Vercel configuration created"));
+  console.log(pc.gray("Created:"));
+  console.log(pc.gray("  - vercel.json"));
+  console.log(pc.gray("  - api/index.ts (handler entry)"));
+  console.log(pc.gray("  - src/server/index.ts (server factory)"));
+}
+
+function showHelp() {
+  console.log(`
+${pc.bold("Deploy Command")}
+
+Usage:
+  donkeylabs deploy [platform]
+
+Platforms:
+  vercel    Deploy to Vercel (serverless)
+
+Examples:
+  donkeylabs deploy vercel
+
+Prerequisites:
+  - Vercel CLI: npm install -g vercel
+  - PostgreSQL database (SQLite won't work on serverless)
+  - DATABASE_URL in .env.local
+
+First time setup:
+  1. Run: vercel login
+  2. Run: donkeylabs deploy vercel
+  3. Follow prompts to link project
+
+Note: Serverless deployment requires PostgreSQL.
+SQLite is file-based and won't persist across serverless invocations.
+`);
+}

package/src/commands/generate.ts

@@ -769,18 +769,11 @@ export async function generateCommand(_args: string[]): Promise<void> {
 
   // Generate client using adapter (required for SvelteKit projects)
   if (config.adapter) {
-    // Resolve the adapter path from the project's node_modules
-    const adapterPath = join(process.cwd(), "node_modules", config.adapter, "src/generator/index.ts");
-
-    if (!existsSync(adapterPath)) {
-      console.error(pc.red(`Adapter not found: ${config.adapter}`));
-      console.error(pc.dim(`Expected path: ${adapterPath}`));
-      console.error(pc.dim(`Run: bun install`));
-      process.exit(1);
-    }
+    // Use the package's subpath export (e.g., @donkeylabs/adapter-sveltekit/generator)
+    const adapterGeneratorPath = `${config.adapter}/generator`;
 
     try {
-      const adapterModule = await import(adapterPath);
+      const adapterModule = await import(adapterGeneratorPath);
       if (!adapterModule.generateClient) {
         console.error(pc.red(`Adapter ${config.adapter} does not export generateClient`));
         process.exit(1);
@@ -788,9 +781,14 @@ export async function generateCommand(_args: string[]): Promise<void> {
       await adapterModule.generateClient(config, serverRoutes, clientOutput);
       generated.push(`client (${config.adapter})`);
     } catch (e: any) {
-      console.error(pc.red(`Failed to run adapter generator: ${config.adapter}`));
-      console.error(pc.dim(e.message));
-      if (e.stack) console.error(pc.dim(e.stack));
+      if (e.code === 'ERR_MODULE_NOT_FOUND' || e.message?.includes('Cannot find')) {
+        console.error(pc.red(`Adapter not found: ${config.adapter}`));
+        console.error(pc.dim(`Make sure the adapter is installed: bun add ${config.adapter}`));
+      } else {
+        console.error(pc.red(`Failed to run adapter generator: ${config.adapter}`));
+        console.error(pc.dim(e.message));
+        if (e.stack) console.error(pc.dim(e.stack));
+      }
       process.exit(1);
     }
   } else {