create-kide-app 0.1.1 → 0.1.3

package/index.js

@@ -1,12 +1,18 @@
 #!/usr/bin/env node
 
 import * as p from "@clack/prompts";
-import { execSync } from "node:child_process";
+import { exec as execCb, execSync } from "node:child_process";
 import { cpSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
+import { promisify } from "node:util";
 
+const exec = promisify(execCb);
 const REPO = "https://github.com/mhernesniemi/kide-cms.git";
 
+function run(cmd, cwd) {
+  return exec(cmd, { cwd });
+}
+
 function applyPackagePatch(pkg, patch) {
   for (const [k, v] of Object.entries(patch.dependencies?.add ?? {})) {
     pkg.dependencies[k] = v;
@@ -61,13 +67,32 @@ async function main() {
     process.exit(0);
   }
 
+  let seedDemo = false;
+  if (!cloudflare) {
+    const seed = await p.confirm({
+      message: "Seed database with demo content?",
+      initialValue: false,
+    });
+    if (p.isCancel(seed)) {
+      p.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    seedDemo = seed;
+  }
+
   const s = p.spinner();
 
+  // --- Clone kide-cms ---
+
   s.start("Cloning kide-cms");
-  execSync(`git clone --depth 1 ${REPO} "${projectDir}"`, { stdio: "pipe" });
+  await run(`git clone --depth 1 ${REPO} "${projectDir}"`);
   rmSync(path.join(projectDir, ".git"), { recursive: true, force: true });
   s.stop("Cloned");
 
+  // --- Adjust package.json and apply adapter overlay ---
+
+  s.start(cloudflare ? "Applying Cloudflare adapter" : "Configuring project");
+
   const pkgPath = path.join(projectDir, "package.json");
   const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
   pkg.name = projectName;
@@ -76,9 +101,7 @@ async function main() {
   const adaptersDir = path.join(projectDir, "adapters");
 
   if (cloudflare) {
-    s.start("Applying Cloudflare adapter");
     const cfDir = path.join(adaptersDir, "cloudflare");
-
     const overlayFiles = [
       "astro.config.mjs",
       "drizzle.config.ts",
@@ -98,45 +121,194 @@ async function main() {
 
     const patch = JSON.parse(readFileSync(path.join(cfDir, "package.patch.json"), "utf-8"));
     applyPackagePatch(pkg, patch);
-
-    s.stop("Cloudflare adapter applied");
   }
 
   rmSync(adaptersDir, { recursive: true, force: true });
   writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
 
+  s.stop(cloudflare ? "Cloudflare adapter applied" : "Project configured");
+
+  // --- Install dependencies ---
+
   s.start("Installing dependencies");
   try {
-    execSync("pnpm install", { cwd: projectDir, stdio: "pipe" });
+    await run("pnpm install", projectDir);
     s.stop("Dependencies installed");
   } catch {
     s.stop("pnpm install failed — run it manually");
   }
 
+  // --- Seed demo content (local only) ---
+
+  if (seedDemo) {
+    s.start("Generating CMS schema");
+    try {
+      await run("pnpm cms:generate", projectDir);
+      s.stop("Schema generated");
+    } catch {
+      s.stop("Schema generation failed — run `pnpm cms:generate` manually");
+    }
+
+    s.start("Pushing schema to database");
+    try {
+      await run("pnpm exec drizzle-kit push --force", projectDir);
+      s.stop("Schema pushed");
+    } catch {
+      s.stop("Schema push failed — will be set up on first dev start");
+    }
+
+    s.start("Seeding demo content");
+    try {
+      await run("pnpm cms:seed", projectDir);
+      s.stop("Demo content seeded");
+    } catch {
+      s.stop("Seeding failed — run `pnpm cms:seed` manually");
+    }
+  }
+
+  // --- Cloudflare resource setup ---
+
+  const cf = { d1Created: false, r2Created: false, migrationsApplied: false };
   if (cloudflare) {
-    p.note(
-      [
-        `cd ${projectName}`,
-        "",
-        "1. Create Cloudflare resources:",
-        `   pnpm wrangler d1 create ${projectName}-db`,
-        "   # Paste the database_id into wrangler.toml",
-        `   pnpm wrangler r2 bucket create ${projectName}-assets`,
-        "",
-        "2. Generate and apply migrations:",
-        "   pnpm cms:generate && pnpm exec drizzle-kit generate",
-        `   pnpm wrangler d1 migrations apply ${projectName}-db --remote`,
-        "",
-        "3. Run locally or deploy:",
-        "   pnpm dev",
-        "   pnpm deploy",
-      ].join("\n"),
-      "Next steps",
-    );
+    const setupNow = await p.confirm({
+      message: "Set up Cloudflare resources now? (creates D1 database and R2 bucket)",
+      initialValue: true,
+    });
+
+    if (!p.isCancel(setupNow) && setupNow) {
+      // Check wrangler authentication
+      let authenticated = false;
+      try {
+        await run("pnpm wrangler whoami", projectDir);
+        authenticated = true;
+      } catch {
+        p.note("You need to log in to Cloudflare first.", "Wrangler login required");
+        const doLogin = await p.confirm({ message: "Open browser to log in?", initialValue: true });
+        if (!p.isCancel(doLogin) && doLogin) {
+          try {
+            execSync("pnpm wrangler login", { cwd: projectDir, stdio: "inherit" });
+            authenticated = true;
+          } catch {
+            // Login failed
+          }
+        }
+      }
+
+      if (authenticated) {
+        // Create D1 database
+        let databaseId = null;
+        s.start("Creating D1 database");
+        try {
+          const { stdout } = await run(`pnpm wrangler d1 create ${projectName}-db`, projectDir);
+          const match = stdout.match(/database_id\s*=\s*"([^"]+)"/);
+          if (match) databaseId = match[1];
+          cf.d1Created = true;
+          s.stop("D1 database created");
+        } catch {
+          // Already exists — look it up
+          try {
+            const { stdout } = await run("pnpm wrangler d1 list", projectDir);
+            const dbLine = stdout.split("\n").find((l) => l.includes(`${projectName}-db`));
+            if (dbLine) {
+              const idMatch = dbLine.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/);
+              if (idMatch) databaseId = idMatch[0];
+            }
+            if (databaseId) {
+              cf.d1Created = true;
+              s.stop("D1 database already exists — using existing");
+            } else {
+              s.stop("D1 setup failed");
+            }
+          } catch {
+            s.stop("D1 setup failed");
+          }
+        }
+
+        // Update wrangler.toml with database_id
+        if (databaseId) {
+          const wranglerPath = path.join(projectDir, "wrangler.toml");
+          let wranglerContent = readFileSync(wranglerPath, "utf-8");
+          wranglerContent = wranglerContent.replace(
+            /database_id = "" #[^\n]*/,
+            `database_id = "${databaseId}"`,
+          );
+          writeFileSync(wranglerPath, wranglerContent);
+        }
+
+        // Create R2 bucket
+        s.start("Creating R2 bucket");
+        try {
+          await run(`pnpm wrangler r2 bucket create ${projectName}-assets`, projectDir);
+          cf.r2Created = true;
+          s.stop("R2 bucket created");
+        } catch {
+          // Already exists is fine
+          cf.r2Created = true;
+          s.stop("R2 bucket already exists");
+        }
+
+        // Generate schema + migrations, apply to remote D1
+        if (databaseId) {
+          s.start("Generating CMS schema");
+          try {
+            await run("pnpm cms:generate", projectDir);
+            s.stop("Schema generated");
+          } catch {
+            s.stop("Schema generation failed");
+          }
+
+          s.start("Generating database migrations");
+          try {
+            await run("pnpm exec drizzle-kit generate", projectDir);
+            s.stop("Migrations generated");
+          } catch {
+            s.stop("Migration generation failed");
+          }
+
+          s.start("Applying migrations to remote D1");
+          try {
+            await run(`pnpm wrangler d1 migrations apply ${projectName}-db --remote`, projectDir);
+            cf.migrationsApplied = true;
+            s.stop("Migrations applied");
+          } catch {
+            s.stop("Migration apply failed — run manually with: wrangler d1 migrations apply --remote");
+          }
+        }
+      }
+    }
+  }
+
+  // --- Done ---
+
+  if (cloudflare) {
+    const lines = [`cd ${projectName}`];
+    const remaining = [];
+    if (!cf.d1Created) {
+      remaining.push(
+        `  pnpm wrangler d1 create ${projectName}-db`,
+        "  # Paste the database_id into wrangler.toml",
+      );
+    }
+    if (!cf.r2Created) {
+      remaining.push(`  pnpm wrangler r2 bucket create ${projectName}-assets`);
+    }
+    if (!cf.migrationsApplied) {
+      remaining.push(`  pnpm wrangler d1 migrations apply ${projectName}-db --remote`);
+    }
+    if (remaining.length > 0) {
+      lines.push("", "Remaining setup:", ...remaining);
+    }
+    lines.push("", "Local development:", "  pnpm dev", "", "Deploy:", "  pnpm deploy");
+    p.note(lines.join("\n"), "Next steps");
     p.outro("Project created!");
   } else {
-    p.note([`cd ${projectName}`, "pnpm dev"].join("\n"), "Next steps");
-    p.outro("Project created!");
+    p.outro("Starting dev server...");
+    try {
+      execSync("pnpm dev", { cwd: projectDir, stdio: "inherit" });
+    } catch {
+      console.log(`\n  Project directory: ${projectDir}`);
+      console.log(`  To start again:   cd ${projectName} && pnpm dev\n`);
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-kide-app",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Scaffold a new Kide CMS project",
   "author": "Matti Hernesniemi",
   "license": "MIT",