create-apollo-monorepo 0.1.0

package/README.md

@@ -0,0 +1,65 @@
+# create-apollo-monorepo
+
+Scaffold a pnpm monorepo where your custom frontend lives alongside Apollo CMS
+mounted as a **git submodule** backend (read-only — pull updates only).
+
+## Usage
+
+```bash
+npx create-apollo-monorepo thamc-new
+```
+
+With flags:
+
+```bash
+npx create-apollo-monorepo thamc-new \
+  --frontend-name "@thamc/frontend" \
+  --db "postgresql://user:pass@localhost:5432/thamc" \
+  --url "http://localhost:3000" \
+  --locale th
+```
+
+## Result
+
+```
+thamc-new/
+├── apps/
+│   ├── frontend/          ← @thamc/frontend (Next.js skeleton)
+│   └── backend/           ← git submodule → apollo-cms
+├── package.json           ← root workspace
+├── pnpm-workspace.yaml
+├── .env.local             ← shared dev env
+├── .gitmodules            ← submodule config
+└── .gitignore
+```
+
+## Flags
+
+| Flag                       | Default                                 | Description                          |
+| -------------------------- | --------------------------------------- | ------------------------------------ |
+| `--frontend-name <name>`   | `@<dir>/frontend`                       | Frontend `package.json` name         |
+| `--backend-url <url>`      | `https://github.com/5Lab-Group-Co-Ltd/apollo-cms.git` | Submodule git URL          |
+| `--backend-branch <name>`  | `main`                                  | Submodule branch to track            |
+| `-d, --db <url>`           | _(prompted)_                            | `DATABASE_URL` for backend           |
+| `-u, --url <url>`          | `http://localhost:3000`                 | `NEXT_PUBLIC_SITE_URL`               |
+| `-l, --locale <code>`      | `en`                                    | `NEXT_PUBLIC_DEFAULT_LOCALE`         |
+| `--skip-install`           | off                                     | Don't run `pnpm install`             |
+| `--skip-submodule`         | off                                     | Don't add the git submodule          |
+| `-h, --help`               | —                                       | Show help                            |
+
+## After install
+
+```bash
+cd thamc-new
+pnpm backend:setup   # push schema + seed apollo-cms
+pnpm dev             # frontend :3001 + backend :3000 in parallel
+```
+
+## Updating the backend
+
+```bash
+pnpm backend:update  # git submodule update --remote --merge apps/backend
+```
+
+Don't edit files inside `apps/backend` — open issues / PRs against the
+`apollo-cms` repository upstream.

package/index.mjs

@@ -0,0 +1,583 @@
+#!/usr/bin/env node
+
+// create-apollo-monorepo — Zero-dependency scaffolder for an Apollo CMS monorepo
+// Usage: npx create-apollo-monorepo <directory> [flags]
+//
+// Produces:
+//   <directory>/
+//   ├── apps/
+//   │   ├── frontend/        ← your app (pnpm workspace member)
+//   │   └── backend/         ← git submodule → apollo-cms
+//   ├── package.json
+//   ├── pnpm-workspace.yaml
+//   ├── .env.local
+//   ├── .gitmodules
+//   └── .gitignore
+
+import { execSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { createInterface } from "node:readline";
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const BACKEND_REPO_URL = "https://github.com/5Lab-Group-Co-Ltd/apollo-cms.git";
+const BACKEND_BRANCH = "main";
+const BACKEND_PATH = "apps/backend";
+const FRONTEND_PATH = "apps/frontend";
+const MIN_NODE_MAJOR = 20;
+
+const COLORS = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+};
+
+const HELP_TEXT = `
+${COLORS.bold}create-apollo-monorepo${COLORS.reset} — Scaffold a monorepo with Apollo CMS as a git submodule backend
+
+${COLORS.bold}Usage:${COLORS.reset}
+  npx create-apollo-monorepo <directory> [flags]
+
+${COLORS.bold}Examples:${COLORS.reset}
+  npx create-apollo-monorepo thamc-new
+  npx create-apollo-monorepo thamc-new --frontend-name "@thamc/frontend"
+  npx create-apollo-monorepo thamc-new --backend-branch develop --skip-install
+
+${COLORS.bold}Flags:${COLORS.reset}
+      --frontend-name <name>   Frontend package name (default: "@<dir>/frontend")
+      --backend-url <url>      Backend git URL (default: ${BACKEND_REPO_URL})
+      --backend-branch <name>  Backend branch to track (default: ${BACKEND_BRANCH})
+  -d, --db <url>               DATABASE_URL for backend
+  -u, --url <url>              NEXT_PUBLIC_SITE_URL (default: http://localhost:3000)
+  -l, --locale <code>          NEXT_PUBLIC_DEFAULT_LOCALE (default: en)
+      --skip-install           Skip dependency installation
+      --skip-submodule         Skip git submodule add (you'll add it later)
+  -h, --help                   Show this help message
+`;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function log(msg) {
+  console.log(msg);
+}
+
+function step(num, msg) {
+  log(`\n${COLORS.cyan}[${num}]${COLORS.reset} ${msg}`);
+}
+
+function success(msg) {
+  log(`    ${COLORS.green}✓${COLORS.reset} ${msg}`);
+}
+
+function warn(msg) {
+  log(`    ${COLORS.yellow}⚠${COLORS.reset} ${msg}`);
+}
+
+function fatal(msg) {
+  console.error(`\n${COLORS.red}Error:${COLORS.reset} ${msg}\n`);
+  process.exit(1);
+}
+
+function run(cmd, opts = {}) {
+  return execSync(cmd, { stdio: "inherit", ...opts });
+}
+
+function runSilent(cmd, opts = {}) {
+  try {
+    return execSync(cmd, { stdio: "pipe", ...opts }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+
+function commandExists(cmd) {
+  return runSilent(process.platform === "win32" ? `where ${cmd}` : `which ${cmd}`) !== null;
+}
+
+// ─── Arg Parsing ─────────────────────────────────────────────────────────────
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const flags = {
+    directory: null,
+    frontendName: null,
+    backendUrl: BACKEND_REPO_URL,
+    backendBranch: BACKEND_BRANCH,
+    db: null,
+    url: null,
+    locale: null,
+    skipInstall: false,
+    skipSubmodule: false,
+    help: false,
+  };
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        flags.help = true;
+        break;
+      case "--frontend-name":
+        flags.frontendName = args[++i];
+        break;
+      case "--backend-url":
+        flags.backendUrl = args[++i];
+        break;
+      case "--backend-branch":
+        flags.backendBranch = args[++i];
+        break;
+      case "-d":
+      case "--db":
+        flags.db = args[++i];
+        break;
+      case "-u":
+      case "--url":
+        flags.url = args[++i];
+        break;
+      case "-l":
+      case "--locale":
+        flags.locale = args[++i];
+        break;
+      case "--skip-install":
+        flags.skipInstall = true;
+        break;
+      case "--skip-submodule":
+        flags.skipSubmodule = true;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          fatal(`Unknown flag: ${arg}\nRun with --help for usage.`);
+        }
+        if (flags.directory) {
+          fatal(`Unexpected argument: ${arg}\nOnly one directory name is allowed.`);
+        }
+        flags.directory = arg;
+    }
+    i++;
+  }
+
+  return flags;
+}
+
+// ─── Validation ──────────────────────────────────────────────────────────────
+
+function isValidDbUrl(url) {
+  return /^postgres(ql)?:\/\/.+/.test(url);
+}
+
+function isValidUrl(url) {
+  return /^https?:\/\/.+/.test(url);
+}
+
+function isValidLocale(code) {
+  return /^[a-z]{2,5}$/i.test(code);
+}
+
+// ─── Pre-flight ──────────────────────────────────────────────────────────────
+
+function preflight(flags) {
+  step(1, "Pre-flight checks");
+
+  const nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
+  if (nodeMajor < MIN_NODE_MAJOR) {
+    fatal(
+      `Node.js ${MIN_NODE_MAJOR}+ is required (found ${process.versions.node}).\n  Install: https://nodejs.org/`,
+    );
+  }
+  success(`Node.js ${process.versions.node}`);
+
+  if (!commandExists("git")) {
+    fatal("git is required but not found.\n  Install: https://git-scm.com/");
+  }
+  success("git found");
+
+  if (!commandExists("pnpm")) {
+    warn("pnpm not found — install with: npm i -g pnpm  (required for workspaces)");
+  } else {
+    success("pnpm found");
+  }
+
+  const targetDir = resolve(flags.directory);
+  if (existsSync(targetDir)) {
+    fatal(`Directory already exists: ${targetDir}\n  Choose a different name or remove it first.`);
+  }
+  success(`Target: ${targetDir}`);
+
+  return targetDir;
+}
+
+// ─── Prompts ─────────────────────────────────────────────────────────────────
+
+function createPrompt() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((res) => rl.question(q, (a) => res(a.trim())));
+  const close = () => rl.close();
+  return { ask, close };
+}
+
+async function gatherEnv(flags) {
+  let dbUrl = flags.db;
+  let siteUrl = flags.url ?? "http://localhost:3000";
+  let locale = flags.locale ?? "en";
+
+  if (flags.db && !isValidDbUrl(flags.db)) fatal("--db must start with postgresql:// or postgres://");
+  if (flags.url && !isValidUrl(flags.url)) fatal("--url must start with http:// or https://");
+  if (flags.locale && !isValidLocale(flags.locale)) fatal("--locale must be a 2-5 character code (e.g., en, th)");
+
+  const needsPrompt = !dbUrl || !flags.url || !flags.locale;
+  if (!needsPrompt) return { dbUrl, siteUrl, locale };
+
+  const { ask, close } = createPrompt();
+
+  if (!dbUrl) {
+    log("");
+    while (!dbUrl) {
+      const ans = await ask(
+        `    ${COLORS.bold}DATABASE_URL${COLORS.reset} ${COLORS.dim}(postgresql://user:pass@host:5432/dbname)${COLORS.reset}\n    > `,
+      );
+      if (isValidDbUrl(ans)) dbUrl = ans;
+      else warn("Must start with postgresql:// or postgres://");
+    }
+  }
+
+  if (!flags.url) {
+    const ans = await ask(
+      `\n    ${COLORS.bold}NEXT_PUBLIC_SITE_URL${COLORS.reset} ${COLORS.dim}[${siteUrl}]${COLORS.reset}\n    > `,
+    );
+    if (ans) {
+      if (isValidUrl(ans)) siteUrl = ans;
+      else warn(`Invalid URL, using default: ${siteUrl}`);
+    }
+  }
+
+  if (!flags.locale) {
+    const ans = await ask(
+      `\n    ${COLORS.bold}Default locale${COLORS.reset} ${COLORS.dim}[${locale}]${COLORS.reset}\n    > `,
+    );
+    if (ans) {
+      if (isValidLocale(ans)) locale = ans;
+      else warn(`Invalid locale code, using default: ${locale}`);
+    }
+  }
+
+  close();
+  return { dbUrl, siteUrl, locale };
+}
+
+// ─── Scaffolding ─────────────────────────────────────────────────────────────
+
+function writeRootPackageJson(targetDir, dirName) {
+  const pkg = {
+    name: dirName,
+    version: "0.0.0",
+    private: true,
+    description: `${dirName} monorepo (frontend + apollo-cms backend submodule)`,
+    scripts: {
+      dev: "pnpm -r --parallel dev",
+      "dev:frontend": "pnpm --filter ./apps/frontend dev",
+      "dev:backend": "pnpm --filter ./apps/backend dev",
+      build: "pnpm -r build",
+      lint: "pnpm -r lint",
+      typecheck: "pnpm -r typecheck",
+      "backend:update": "git submodule update --remote --merge apps/backend",
+      "backend:setup": "pnpm --filter ./apps/backend setup",
+    },
+    engines: { node: ">=20", pnpm: ">=9" },
+    packageManager: "pnpm@9.0.0",
+  };
+  writeFileSync(resolve(targetDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+}
+
+function writePnpmWorkspace(targetDir) {
+  writeFileSync(
+    resolve(targetDir, "pnpm-workspace.yaml"),
+    "packages:\n  - 'apps/*'\n",
+  );
+}
+
+function writeRootGitignore(targetDir) {
+  const ignore = [
+    "node_modules",
+    ".pnpm-store",
+    ".turbo",
+    ".next",
+    "dist",
+    "build",
+    ".env",
+    ".env.local",
+    ".env*.local",
+    "*.log",
+    ".DS_Store",
+    "",
+  ].join("\n");
+  writeFileSync(resolve(targetDir, ".gitignore"), ignore);
+}
+
+function writeRootEnv(targetDir, { dbUrl, siteUrl, locale, authSecret }) {
+  const lines = [
+    "# Shared dev env — backend reads these via apps/backend/.env.local symlink/copy",
+    `DATABASE_URL=${dbUrl}`,
+    `APOLLO_SECRET=${authSecret}`,
+    `BETTER_AUTH_SECRET=${authSecret}`,
+    `NEXT_PUBLIC_SITE_URL=${siteUrl}`,
+    `NEXT_PUBLIC_DEFAULT_LOCALE=${locale}`,
+    "",
+    "# Frontend",
+    `NEXT_PUBLIC_BACKEND_URL=${siteUrl}`,
+    "",
+  ].join("\n");
+  writeFileSync(resolve(targetDir, ".env.local"), lines);
+}
+
+function writeFrontendApp(targetDir, frontendName, siteUrl) {
+  const dir = resolve(targetDir, FRONTEND_PATH);
+  mkdirSync(dir, { recursive: true });
+  mkdirSync(resolve(dir, "src/app"), { recursive: true });
+  mkdirSync(resolve(dir, "public"), { recursive: true });
+
+  const pkg = {
+    name: frontendName,
+    version: "0.0.0",
+    private: true,
+    scripts: {
+      dev: "next dev -p 3001",
+      build: "next build",
+      start: "next start -p 3001",
+      lint: "next lint",
+      typecheck: "tsc --noEmit",
+    },
+    dependencies: {
+      next: "^16.0.0",
+      react: "^19.0.0",
+      "react-dom": "^19.0.0",
+    },
+    devDependencies: {
+      "@types/node": "^22.0.0",
+      "@types/react": "^19.0.0",
+      "@types/react-dom": "^19.0.0",
+      typescript: "^5.6.0",
+    },
+  };
+  writeFileSync(resolve(dir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+
+  writeFileSync(
+    resolve(dir, "tsconfig.json"),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          lib: ["dom", "dom.iterable", "esnext"],
+          allowJs: true,
+          skipLibCheck: true,
+          strict: true,
+          noEmit: true,
+          esModuleInterop: true,
+          module: "esnext",
+          moduleResolution: "bundler",
+          resolveJsonModule: true,
+          isolatedModules: true,
+          jsx: "preserve",
+          incremental: true,
+          plugins: [{ name: "next" }],
+          paths: { "@/*": ["./src/*"] },
+        },
+        include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+        exclude: ["node_modules"],
+      },
+      null,
+      2,
+    ) + "\n",
+  );
+
+  writeFileSync(
+    resolve(dir, "next.config.ts"),
+    `import type { NextConfig } from "next";\n\nconst config: NextConfig = {\n  reactStrictMode: true,\n};\n\nexport default config;\n`,
+  );
+
+  writeFileSync(
+    resolve(dir, ".env.local.example"),
+    `NEXT_PUBLIC_BACKEND_URL=${siteUrl}\n`,
+  );
+
+  writeFileSync(
+    resolve(dir, "src/app/layout.tsx"),
+    `export const metadata = { title: "Frontend", description: "Apollo CMS frontend" };\n\nexport default function RootLayout({ children }: { children: React.ReactNode }) {\n  return (\n    <html lang="en">\n      <body>{children}</body>\n    </html>\n  );\n}\n`,
+  );
+
+  writeFileSync(
+    resolve(dir, "src/app/page.tsx"),
+    `export default function Page() {\n  return (\n    <main style={{ padding: 40, fontFamily: "system-ui" }}>\n      <h1>Frontend</h1>\n      <p>Backend: <code>{process.env.NEXT_PUBLIC_BACKEND_URL}</code></p>\n    </main>\n  );\n}\n`,
+  );
+
+  writeFileSync(
+    resolve(dir, ".gitignore"),
+    ["node_modules", ".next", "dist", ".env.local", ""].join("\n"),
+  );
+}
+
+function writeReadme(targetDir, dirName, frontendName) {
+  const readme = `# ${dirName}
+
+Monorepo with a custom frontend and Apollo CMS as a git submodule backend.
+
+## Layout
+
+\`\`\`
+${dirName}/
+├── apps/
+│   ├── frontend/   ← ${frontendName}
+│   └── backend/    ← git submodule → apollo-cms (read-only, pull updates)
+├── package.json
+└── pnpm-workspace.yaml
+\`\`\`
+
+## Quick start
+
+\`\`\`bash
+pnpm install
+pnpm backend:setup       # push schema + seed apollo-cms
+pnpm dev                 # runs frontend (3001) + backend (3000) in parallel
+\`\`\`
+
+## Updating the backend
+
+Apollo CMS is tracked as a git submodule. Pull the latest:
+
+\`\`\`bash
+pnpm backend:update
+\`\`\`
+
+Do **not** edit files inside \`apps/backend\`. Open issues / PRs in the
+\`apollo-cms\` repository upstream.
+
+## Environment variables
+
+Shared dev env lives in the root \`.env.local\`. The backend reads its own
+\`apps/backend/.env.local\` (already populated by the installer).
+`;
+  writeFileSync(resolve(targetDir, "README.md"), readme);
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+async function main() {
+  const flags = parseArgs(process.argv);
+
+  if (flags.help) {
+    log(HELP_TEXT);
+    process.exit(0);
+  }
+
+  if (!flags.directory) {
+    log(HELP_TEXT);
+    fatal("Please provide a directory name.\n  Example: npx create-apollo-monorepo thamc-new");
+  }
+
+  log(`\n${COLORS.bold}${COLORS.cyan}  Apollo CMS Monorepo Installer${COLORS.reset}\n`);
+
+  // ── Step 1: Pre-flight ──
+  const targetDir = preflight(flags);
+  const dirName = basename(targetDir);
+  const frontendName = flags.frontendName ?? `@${dirName}/frontend`;
+
+  // ── Step 2: Gather env ──
+  step(2, "Configuring environment");
+  const { dbUrl, siteUrl, locale } = await gatherEnv(flags);
+  const authSecret = randomBytes(48).toString("base64");
+  success(`Frontend pkg name: ${frontendName}`);
+
+  // ── Step 3: Scaffold root ──
+  step(3, "Scaffolding monorepo root");
+  mkdirSync(targetDir, { recursive: true });
+  mkdirSync(resolve(targetDir, "apps"), { recursive: true });
+  writeRootPackageJson(targetDir, dirName);
+  writePnpmWorkspace(targetDir);
+  writeRootGitignore(targetDir);
+  writeRootEnv(targetDir, { dbUrl, siteUrl, locale, authSecret });
+  writeReadme(targetDir, dirName, frontendName);
+  success("package.json, pnpm-workspace.yaml, .gitignore, .env.local, README.md");
+
+  // ── Step 4: git init ──
+  step(4, "Initializing git");
+  run("git init -b main", { cwd: targetDir, stdio: "pipe" });
+  success("git repo initialized");
+
+  // ── Step 5: Frontend skeleton ──
+  step(5, "Creating frontend app");
+  writeFrontendApp(targetDir, frontendName, siteUrl);
+  success(`apps/frontend (${frontendName})`);
+
+  // ── Step 6: Backend submodule ──
+  if (flags.skipSubmodule) {
+    step(6, "Skipping git submodule (--skip-submodule)");
+    warn(
+      `Add it later:\n      cd ${dirName}\n      git submodule add -b ${flags.backendBranch} ${flags.backendUrl} ${BACKEND_PATH}`,
+    );
+  } else {
+    step(6, `Adding apollo-cms as git submodule (${BACKEND_PATH})`);
+    try {
+      run(
+        `git submodule add -b ${flags.backendBranch} ${flags.backendUrl} ${BACKEND_PATH}`,
+        { cwd: targetDir },
+      );
+      run(`git submodule update --init --recursive`, { cwd: targetDir });
+      success("submodule added");
+    } catch {
+      fatal(
+        `Failed to add submodule.\n  Check the URL and your network, then run:\n  cd ${dirName} && git submodule add -b ${flags.backendBranch} ${flags.backendUrl} ${BACKEND_PATH}`,
+      );
+    }
+
+    // Mirror env to backend
+    const backendEnv = [
+      `DATABASE_URL=${dbUrl}`,
+      `APOLLO_SECRET=${authSecret}`,
+      `BETTER_AUTH_SECRET=${authSecret}`,
+      `NEXT_PUBLIC_SITE_URL=${siteUrl}`,
+      `NEXT_PUBLIC_DEFAULT_LOCALE=${locale}`,
+      "",
+    ].join("\n");
+    writeFileSync(resolve(targetDir, BACKEND_PATH, ".env.local"), backendEnv);
+    success("apps/backend/.env.local");
+  }
+
+  // ── Step 7: Install ──
+  if (flags.skipInstall) {
+    step(7, "Skipping dependency installation (--skip-install)");
+    warn(`Run later:\n      cd ${dirName} && pnpm install`);
+  } else if (!commandExists("pnpm")) {
+    step(7, "Skipping dependency installation (pnpm not installed)");
+    warn(`Install pnpm and run:\n      npm i -g pnpm && cd ${dirName} && pnpm install`);
+  } else {
+    step(7, "Installing dependencies (pnpm)");
+    try {
+      run("pnpm install", { cwd: targetDir });
+      success("dependencies installed");
+    } catch {
+      warn(`Install failed — run manually: cd ${dirName} && pnpm install`);
+    }
+  }
+
+  // ── Done ──
+  log(`
+${COLORS.green}${COLORS.bold}  Monorepo created!${COLORS.reset}
+
+  ${COLORS.bold}cd${COLORS.reset} ${dirName}
+  ${COLORS.bold}pnpm backend:setup${COLORS.reset}   ${COLORS.dim}# push schema + seed apollo-cms${COLORS.reset}
+  ${COLORS.bold}pnpm dev${COLORS.reset}             ${COLORS.dim}# frontend :3001 + backend :3000${COLORS.reset}
+
+  ${COLORS.dim}APOLLO_SECRET=${authSecret}${COLORS.reset}
+`);
+}
+
+main().catch((err) => {
+  fatal(err.message ?? String(err));
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "create-apollo-monorepo",
+  "version": "0.1.0",
+  "description": "Scaffold a monorepo with a frontend app and Apollo CMS as a git submodule backend",
+  "bin": "./index.mjs",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "apollo",
+    "cms",
+    "monorepo",
+    "submodule",
+    "pnpm",
+    "workspace",
+    "create",
+    "installer"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/5Lab-Group-Co-Ltd/apollo-cms.git",
+    "directory": "installer-monorepo"
+  },
+  "license": "MIT"
+}