create-kide-app 0.0.1

package/README.md

@@ -0,0 +1,31 @@
+# create-kide-app
+
+Scaffold a new [Kide CMS](https://github.com/mhernesniemi/kide-cms) project.
+
+## Usage
+
+```bash
+npm create kide-app my-project
+# or
+pnpm create kide-app my-project
+# or
+bunx create-kide-app my-project
+```
+
+The CLI will guide you through:
+
+1. **Project name** — directory to create
+2. **Deploy target** — Local/Node.js or Cloudflare
+3. **Demo content** — optionally seed the database
+
+## What it does
+
+- Downloads the latest Kide CMS template from GitHub
+- Applies platform-specific configuration (Node.js adapter, Cloudflare D1/R2, etc.)
+- Installs dependencies
+- Generates the CMS schema
+- Optionally seeds demo content
+
+## Requirements
+
+- Node.js >= 22.12.0

package/index.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+
+import * as p from "@clack/prompts";
+import { execSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = path.join(__dirname, "templates");
+
+// --- Package manager detection ---
+
+const pm = { name: "pnpm", exec: "pnpm dlx", run: "pnpm", install: "pnpm install" };
+
+// --- Template repo URL ---
+const REPO_URL = "https://github.com/mhernesniemi/kide-cms/archive/refs/heads/main.tar.gz";
+
+// --- Main ---
+
+async function main() {
+  p.intro("Create Kide CMS Project");
+
+  // 1. Project name
+  const projectName =
+    process.argv[2] ||
+    (await p.text({
+      message: "Project name",
+      placeholder: "my-cms-app",
+      validate: (value) => {
+        if (!value) return "Project name is required";
+      },
+    }));
+
+  if (p.isCancel(projectName)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+
+  const projectDir = path.resolve(process.cwd(), projectName);
+  if (existsSync(projectDir)) {
+    p.cancel(`Directory "${projectName}" already exists.`);
+    process.exit(1);
+  }
+
+  // 2. Deploy target
+  const target = await p.select({
+    message: "Where will you deploy?",
+    options: [
+      { label: "Local / Node.js", value: "local" },
+      { label: "Cloudflare", value: "cloudflare" },
+    ],
+  });
+
+  if (p.isCancel(target)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+
+  // 3. Demo content
+  const seedDemo = await p.confirm({
+    message: "Seed database with demo content?",
+    initialValue: false,
+  });
+
+  if (p.isCancel(seedDemo)) {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+
+  const s = p.spinner();
+
+  // --- Scaffold ---
+
+  s.start(`Scaffolding project (using ${pm.name})`);
+
+  mkdirSync(projectDir, { recursive: true });
+  const tmpArchive = path.join(projectDir, "_template.tar.gz");
+
+  try {
+    execSync(`curl -sL "${REPO_URL}" -o "${tmpArchive}"`, { stdio: "pipe" });
+    execSync(`tar -xzf "${tmpArchive}" -C "${projectDir}" --strip-components=1`, { stdio: "pipe" });
+    rmSync(tmpArchive, { force: true });
+  } catch {
+    s.message("Archive download failed, trying git clone...");
+    rmSync(projectDir, { recursive: true, force: true });
+    try {
+      execSync(`git clone --depth 1 https://github.com/mhernesniemi/kide-cms.git "${projectDir}"`, {
+        stdio: "pipe",
+      });
+      rmSync(path.join(projectDir, ".git"), { recursive: true, force: true });
+    } catch {
+      s.stop("Failed to download template.");
+      p.cancel("Check your network connection.");
+      process.exit(1);
+    }
+  }
+
+  // Remove files that shouldn't be in the scaffold
+  for (const remove of ["docs", "packages", "CLAUDE.md", ".claude", "data", ".cms-data", "dist", ".astro", ".env"]) {
+    const fp = path.join(projectDir, remove);
+    if (existsSync(fp)) rmSync(fp, { recursive: true, force: true });
+  }
+
+  s.stop("Project scaffolded");
+
+  // --- Apply target-specific files ---
+
+  s.start(`Applying ${target} configuration`);
+
+  const targetDir = path.join(TEMPLATES_DIR, target);
+
+  cpSync(path.join(targetDir, "astro.config.mjs"), path.join(projectDir, "astro.config.mjs"));
+  cpSync(path.join(targetDir, "db.ts"), path.join(projectDir, "src/cms/core/db.ts"));
+  cpSync(path.join(targetDir, "drizzle.config.ts"), path.join(projectDir, "drizzle.config.ts"));
+
+  const pkgPath = path.join(projectDir, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+
+  pkg.name = projectName;
+
+  if (target === "cloudflare") {
+    delete pkg.dependencies["@astrojs/node"];
+    pkg.dependencies["@astrojs/cloudflare"] = "^12.0.0";
+
+    delete pkg.dependencies["better-sqlite3"];
+    if (pkg.devDependencies) delete pkg.devDependencies["@types/better-sqlite3"];
+    if (pkg.pnpm?.onlyBuiltDependencies) {
+      pkg.pnpm.onlyBuiltDependencies = pkg.pnpm.onlyBuiltDependencies.filter((d) => d !== "better-sqlite3");
+      if (pkg.pnpm.onlyBuiltDependencies.length === 0) delete pkg.pnpm.onlyBuiltDependencies;
+      if (Object.keys(pkg.pnpm).length === 0) delete pkg.pnpm;
+    }
+
+    let wranglerContent = readFileSync(path.join(targetDir, "wrangler.toml"), "utf-8");
+    wranglerContent = wranglerContent.replaceAll("{{PROJECT_NAME}}", projectName);
+    writeFileSync(path.join(projectDir, "wrangler.toml"), wranglerContent);
+
+    pkg.devDependencies.wrangler = "^4.0.0";
+
+    pkg.scripts.dev = "astro dev";
+    pkg.scripts.build = "astro build";
+    pkg.scripts.preview = "wrangler pages dev ./dist";
+    pkg.scripts.deploy = "astro build && wrangler pages deploy ./dist";
+  }
+
+  writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+
+  if (target === "cloudflare") {
+    const gitignorePath = path.join(projectDir, ".gitignore");
+    let gitignore = readFileSync(gitignorePath, "utf-8");
+    gitignore += "\n# Cloudflare\n.wrangler/\n";
+    writeFileSync(gitignorePath, gitignore);
+  }
+
+  s.stop("Configuration applied");
+
+  // --- Install dependencies ---
+
+  s.start("Installing dependencies");
+  try {
+    execSync(pm.install, { cwd: projectDir, stdio: "pipe" });
+    s.stop("Dependencies installed");
+  } catch {
+    s.stop(`${pm.install} failed — run it manually`);
+  }
+
+  // --- Generate schema ---
+
+  s.start("Generating CMS schema");
+  try {
+    execSync(`${pm.run} cms:generate`, { cwd: projectDir, stdio: "pipe" });
+    s.stop("Schema generated");
+  } catch {
+    s.stop("Schema generation failed — run `cms:generate` manually");
+  }
+
+  // --- Seed demo content ---
+
+  if (seedDemo && target === "local") {
+    s.start("Pushing schema to database");
+    try {
+      execSync(`${pm.exec} drizzle-kit push --force`, { cwd: projectDir, stdio: "pipe" });
+      s.stop("Schema pushed");
+    } catch {
+      s.stop("Schema push failed — will retry on dev start");
+    }
+    s.start("Seeding demo content");
+    try {
+      execSync(`${pm.run} cms:seed`, { cwd: projectDir, stdio: "pipe" });
+      s.stop("Demo content seeded");
+    } catch {
+      s.stop("Seeding failed — run `pnpm cms:seed` manually");
+    }
+  } else if (seedDemo && target === "cloudflare") {
+    p.note(
+      [
+        "Seeding for Cloudflare requires a D1 database.",
+        "",
+        `  ${pm.exec} wrangler d1 create ${projectName}-db`,
+        "  # Add the database_id to wrangler.toml",
+        `  ${pm.exec} wrangler d1 execute --local --file=./src/cms/migrations/0000_*.sql`,
+        `  ${pm.run} cms:seed`,
+      ].join("\n"),
+      "Seed manually",
+    );
+  }
+
+  // --- Done ---
+
+  if (target === "local") {
+    p.outro("Starting dev server...");
+    try {
+      execSync(`${pm.run} dev`, { cwd: projectDir, stdio: "inherit" });
+    } catch {
+      console.log(`\n  Project directory: ${projectDir}`);
+      console.log(`  To start again:   cd ${projectName} && pnpm dev\n`);
+    }
+  } else {
+    p.note(
+      [
+        "Set up Cloudflare resources:",
+        `  ${pm.exec} wrangler d1 create ${projectName}-db`,
+        `  ${pm.exec} wrangler r2 bucket create ${projectName}-assets`,
+        "  # Add the database_id to wrangler.toml",
+        "",
+        "Local development:",
+        `  cd ${projectName} && ${pm.run} dev`,
+        "",
+        "Deploy:",
+        `  ${pm.run} deploy`,
+      ].join("\n"),
+      "Next steps",
+    );
+    p.outro("Project created!");
+  }
+}
+
+main().catch((err) => {
+  p.cancel(err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "create-kide-app",
+  "version": "0.0.1",
+  "description": "Scaffold a new Kide CMS project",
+  "author": "Matti Hernesniemi",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "create-kide-app": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "templates"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mhernesniemi/create-kide-app"
+  },
+  "homepage": "https://github.com/mhernesniemi/kide-cms",
+  "keywords": [
+    "astro",
+    "cms",
+    "kide",
+    "create-app",
+    "scaffold"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0"
+  }
+}

package/templates/cloudflare/astro.config.mjs

@@ -0,0 +1,24 @@
+// @ts-check
+import cloudflare from "@astrojs/cloudflare";
+import react from "@astrojs/react";
+import tailwindcss from "@tailwindcss/vite";
+import { defineConfig } from "astro/config";
+import cmsIntegration from "./src/cms/integration";
+
+// https://astro.build/config
+export default defineConfig({
+  output: "server",
+  integrations: [react(), cmsIntegration()],
+  adapter: cloudflare({
+    platformProxy: {
+      enabled: true,
+    },
+  }),
+  vite: {
+    plugins: [tailwindcss()],
+    resolve: {
+      // Ensure Cloudflare-compatible modules are used
+      conditions: ["workerd", "worker", "browser"],
+    },
+  },
+});

package/templates/cloudflare/db.ts

@@ -0,0 +1,24 @@
+import { drizzle } from "drizzle-orm/d1";
+
+let dbInstance: ReturnType<typeof drizzle> | null = null;
+let currentDb: D1Database | null = null;
+
+export const getDb = async () => {
+  // Access the D1 binding from the Cloudflare runtime context
+  // The binding is set in wrangler.toml as "CMS_DB"
+  const env = (globalThis as any).__env__;
+  if (!env?.CMS_DB) {
+    throw new Error("D1 database binding CMS_DB not found. Check wrangler.toml.");
+  }
+
+  if (dbInstance && currentDb === env.CMS_DB) return dbInstance;
+
+  currentDb = env.CMS_DB;
+  dbInstance = drizzle(env.CMS_DB);
+  return dbInstance;
+};
+
+export const closeDb = () => {
+  dbInstance = null;
+  currentDb = null;
+};

package/templates/cloudflare/drizzle.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/cms/.generated/schema.ts",
+  out: "./src/cms/migrations",
+  dialect: "sqlite",
+  dbCredentials: {
+    // For local dev with wrangler, point to the local D1 database
+    url: ".wrangler/state/v3/d1/miniflare-D1DatabaseObject/*.sqlite",
+  },
+});

package/templates/cloudflare/wrangler.toml

@@ -0,0 +1,13 @@
+name = "{{PROJECT_NAME}}"
+compatibility_date = "2025-01-01"
+compatibility_flags = ["nodejs_compat"]
+
+[[d1_databases]]
+binding = "CMS_DB"
+database_name = "{{PROJECT_NAME}}-db"
+database_id = "" # Run: npx wrangler d1 create {{PROJECT_NAME}}-db
+
+[[r2_buckets]]
+binding = "CMS_ASSETS"
+bucket_name = "{{PROJECT_NAME}}-assets"
+# Run: npx wrangler r2 bucket create {{PROJECT_NAME}}-assets

package/templates/local/astro.config.mjs

@@ -0,0 +1,23 @@
+// @ts-check
+import node from "@astrojs/node";
+import react from "@astrojs/react";
+import tailwindcss from "@tailwindcss/vite";
+import { defineConfig, memoryCache } from "astro/config";
+import cmsIntegration from "./src/cms/integration";
+
+// https://astro.build/config
+export default defineConfig({
+  output: "server",
+  integrations: [react(), cmsIntegration()],
+  adapter: node({
+    mode: "standalone",
+  }),
+  vite: {
+    plugins: [tailwindcss()],
+  },
+  experimental: {
+    cache: {
+      provider: memoryCache(),
+    },
+  },
+});

package/templates/local/db.ts

@@ -0,0 +1,50 @@
+import { mkdirSync } from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+
+let dbInstance: ReturnType<typeof drizzle> | null = null;
+let sqliteInstance: InstanceType<typeof Database> | null = null;
+let migrated = false;
+
+const getDbPath = () => {
+  const url = process.env.CMS_DATABASE_URL;
+  if (url) return url;
+  return path.join(process.cwd(), "data", "cms.db");
+};
+
+export const getDb = async () => {
+  if (dbInstance) return dbInstance;
+
+  const dbPath = getDbPath();
+  mkdirSync(path.dirname(dbPath), { recursive: true });
+
+  sqliteInstance = new Database(dbPath);
+  sqliteInstance.pragma("journal_mode = WAL");
+  sqliteInstance.pragma("foreign_keys = ON");
+
+  dbInstance = drizzle(sqliteInstance);
+
+  // Auto-run pending migrations on first connection (production only — dev uses drizzle-kit push)
+  if (!migrated) {
+    const migrationsFolder = path.join(process.cwd(), "src/cms/migrations");
+    try {
+      migrate(dbInstance, { migrationsFolder });
+    } catch {
+      // Ignore migration errors — tables may already exist via drizzle-kit push in dev
+    }
+    migrated = true;
+  }
+
+  return dbInstance;
+};
+
+export const closeDb = () => {
+  if (sqliteInstance) {
+    sqliteInstance.close();
+    sqliteInstance = null;
+    dbInstance = null;
+    migrated = false;
+  }
+};

package/templates/local/drizzle.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./src/cms/.generated/schema.ts",
+  out: "./src/cms/migrations",
+  dialect: "sqlite",
+  dbCredentials: {
+    url: process.env.CMS_DATABASE_URL ?? "./data/cms.db",
+  },
+});