create-cfast 0.0.1

package/dist/index.js

@@ -0,0 +1,681 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { green as green2, cyan, bold, yellow } from "kolorist";
+
+// src/args.ts
+var BOOLEAN_FLAGS = ["auth", "db", "storage", "email", "ui", "admin", "all", "help"];
+function parseArgs(argv) {
+  const args = {
+    projectName: void 0,
+    auth: false,
+    db: false,
+    storage: false,
+    email: false,
+    ui: false,
+    admin: false,
+    all: false,
+    help: false
+  };
+  for (const arg of argv) {
+    if (arg.startsWith("--")) {
+      const flag = arg.slice(2);
+      if (BOOLEAN_FLAGS.includes(flag)) {
+        args[flag] = true;
+      }
+    } else if (!args.projectName) {
+      args.projectName = arg;
+    }
+  }
+  return args;
+}
+function printHelp() {
+  console.log(`
+  Usage: create-cfast [project-name] [options]
+
+  Options:
+    --auth       Include @cfast/auth (magic email + passkeys)
+    --db         Include @cfast/db (D1 + Drizzle ORM)
+    --storage    Include @cfast/storage (R2 file uploads)
+    --email      Include @cfast/email (email sending)
+    --ui         Include @cfast/ui (components + actions)
+    --admin      Include @cfast/admin (admin panel)
+    --all        Include all packages
+    --help       Show this help message
+  `);
+}
+
+// src/prompts.ts
+import prompts from "prompts";
+import { green } from "kolorist";
+
+// src/types.ts
+var FEATURE_NAMES = ["auth", "db", "storage", "email", "ui", "admin"];
+
+// src/config.ts
+function resolveFeatureDeps(features) {
+  const resolved = { ...features };
+  if (resolved.admin) {
+    resolved.db = true;
+    resolved.ui = true;
+    resolved.auth = true;
+  }
+  if (resolved.auth) {
+    resolved.db = true;
+  }
+  return resolved;
+}
+function getAutoAddedFeatures(original, resolved) {
+  const added = [];
+  for (const key of Object.keys(resolved)) {
+    if (resolved[key] && !original[key]) {
+      added.push(key);
+    }
+  }
+  return added;
+}
+function resolveConfig(raw) {
+  const features = resolveFeatureDeps(raw.features);
+  const uiLibrary = features.ui ? raw.uiLibrary ?? "joy" : null;
+  return { ...raw, features, uiLibrary };
+}
+
+// src/prompts.ts
+var FEATURE_LABELS = {
+  auth: "@cfast/auth \u2014 Authentication (magic email + passkeys)",
+  db: "@cfast/db \u2014 D1 database with Drizzle ORM",
+  storage: "@cfast/storage \u2014 R2 file uploads",
+  email: "@cfast/email \u2014 Email via Mailgun",
+  ui: "@cfast/ui \u2014 Permission-aware components + actions",
+  admin: "@cfast/admin \u2014 Admin panel"
+};
+async function promptForConfig(args) {
+  let projectName = args.projectName;
+  if (!projectName) {
+    const result = await prompts({
+      type: "text",
+      name: "projectName",
+      message: "Project name:",
+      initial: "my-cfast-app"
+    });
+    if (!result.projectName) return null;
+    projectName = result.projectName;
+  }
+  const hasAnyFeatureFlag = FEATURE_NAMES.some((f) => args[f]) || args.all;
+  let selectedFeatures;
+  if (args.all) {
+    selectedFeatures = [...FEATURE_NAMES];
+  } else if (hasAnyFeatureFlag) {
+    selectedFeatures = FEATURE_NAMES.filter((f) => args[f]);
+  } else {
+    const result = await prompts({
+      type: "multiselect",
+      name: "features",
+      message: "Which packages do you need?",
+      choices: FEATURE_NAMES.map((name) => ({
+        title: FEATURE_LABELS[name],
+        value: name
+      }))
+    });
+    if (!result.features) return null;
+    selectedFeatures = result.features;
+  }
+  const features = {
+    auth: selectedFeatures.includes("auth"),
+    db: selectedFeatures.includes("db"),
+    storage: selectedFeatures.includes("storage"),
+    email: selectedFeatures.includes("email"),
+    ui: selectedFeatures.includes("ui"),
+    admin: selectedFeatures.includes("admin")
+  };
+  const resolved = resolveFeatureDeps(features);
+  const autoAdded = getAutoAddedFeatures(features, resolved);
+  if (autoAdded.length > 0) {
+    console.log(green(`  Added automatically: ${autoAdded.join(", ")}`));
+  }
+  let uiLibrary = null;
+  if (resolved.ui) {
+    if (hasAnyFeatureFlag) {
+      uiLibrary = "joy";
+    } else {
+      const result = await prompts({
+        type: "select",
+        name: "uiLibrary",
+        message: "UI library:",
+        choices: [
+          { title: "MUI Joy UI", value: "joy" },
+          { title: "Headless (bring your own)", value: "headless" }
+        ]
+      });
+      if (result.uiLibrary === void 0) return null;
+      uiLibrary = result.uiLibrary;
+    }
+  }
+  const targetDir = projectName;
+  return resolveConfig({
+    projectName,
+    targetDir,
+    features: resolved,
+    uiLibrary
+  });
+}
+
+// src/scaffold.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/utils.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function getTemplatesDir() {
+  return path.resolve(__dirname, "..", "templates");
+}
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const destName = entry.name === "_gitignore" ? ".gitignore" : entry.name;
+    const destPath = path.join(dest, destName);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      if (entry.name === "package.json" || entry.name === "wrangler.toml") {
+        continue;
+      }
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function replaceInDir(dir, replacements) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      replaceInDir(fullPath, replacements);
+    } else {
+      replaceInFile(fullPath, replacements);
+    }
+  }
+}
+function replaceInFile(filePath, replacements) {
+  const ext = path.extname(filePath);
+  const textExts = [".ts", ".tsx", ".js", ".json", ".toml", ".md", ".html", ".css", ""];
+  if (!textExts.includes(ext) && !filePath.endsWith(".gitignore")) return;
+  let content = fs.readFileSync(filePath, "utf-8");
+  for (const [key, value] of Object.entries(replacements)) {
+    content = content.replaceAll(`{{${key}}}`, value);
+  }
+  fs.writeFileSync(filePath, content);
+}
+function readJsonFragment(filePath) {
+  if (!fs.existsSync(filePath)) return {};
+  return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function writeFile(filePath, content) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+// src/generators/package-json.ts
+function mergePackageJsons(base, fragments) {
+  const merged = {
+    name: base.name,
+    private: base.private,
+    type: base.type,
+    scripts: { ...base.scripts },
+    dependencies: { ...base.dependencies },
+    devDependencies: { ...base.devDependencies }
+  };
+  for (const fragment of fragments) {
+    if (fragment.dependencies) {
+      merged.dependencies = { ...merged.dependencies, ...fragment.dependencies };
+    }
+    if (fragment.devDependencies) {
+      merged.devDependencies = {
+        ...merged.devDependencies,
+        ...fragment.devDependencies
+      };
+    }
+    if (fragment.scripts) {
+      merged.scripts = { ...merged.scripts, ...fragment.scripts };
+    }
+  }
+  if (merged.dependencies) {
+    merged.dependencies = sortKeys(merged.dependencies);
+  }
+  if (merged.devDependencies) {
+    merged.devDependencies = sortKeys(merged.devDependencies);
+  }
+  return merged;
+}
+function sortKeys(obj) {
+  return Object.fromEntries(
+    Object.entries(obj).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+function stringifyPackageJson(pkg) {
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+
+// src/generators/wrangler-toml.ts
+function generateWranglerToml(config) {
+  const lines = [];
+  lines.push(`name = "${config.projectName}"`);
+  lines.push(`compatibility_date = "2025-12-01"`);
+  lines.push(`compatibility_flags = ["nodejs_compat"]`);
+  lines.push(`main = "./workers/app.ts"`);
+  const vars = [
+    ["APP_URL", "http://localhost:5173"]
+  ];
+  if (config.features.email) {
+    vars.push(["MAILGUN_DOMAIN", "sandbox.mailgun.org"]);
+  }
+  lines.push("");
+  lines.push("[vars]");
+  for (const [key, value] of vars) {
+    lines.push(`${key} = "${value}"`);
+  }
+  if (config.features.db) {
+    lines.push("");
+    lines.push("[[d1_databases]]");
+    lines.push(`binding = "DB"`);
+    lines.push(`database_name = "${config.projectName}"`);
+    lines.push(`database_id = "local"`);
+    lines.push(`migrations_dir = "drizzle"`);
+  }
+  if (config.features.storage) {
+    lines.push("");
+    lines.push("[[r2_buckets]]");
+    lines.push(`binding = "UPLOADS"`);
+    lines.push(`bucket_name = "${config.projectName}-uploads"`);
+  }
+  if (config.features.auth) {
+    lines.push("");
+    lines.push("[[kv_namespaces]]");
+    lines.push(`binding = "CACHE"`);
+    lines.push(`id = "local"`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/generators/env.ts
+function generateEnv(config) {
+  const bindings = [];
+  bindings.push(
+    `  APP_URL: { type: "var" as const, default: "http://localhost:5173" },`
+  );
+  if (config.features.db) {
+    bindings.push(`  DB: { type: "d1" as const },`);
+  }
+  if (config.features.storage) {
+    bindings.push(`  UPLOADS: { type: "r2" as const },`);
+  }
+  if (config.features.auth) {
+    bindings.push(`  CACHE: { type: "kv" as const },`);
+  }
+  if (config.features.email) {
+    bindings.push(`  MAILGUN_API_KEY: { type: "secret" as const },`);
+    bindings.push(`  MAILGUN_DOMAIN: { type: "var" as const },`);
+  }
+  return `import { defineEnv } from "@cfast/env";
+
+export const envSchema = {
+${bindings.join("\n")}
+};
+
+export const env = defineEnv(envSchema);
+
+export type Env = ReturnType<typeof env.get>;
+`;
+}
+
+// src/generators/cfast-server.ts
+function generateCfastServer(config) {
+  const imports = [
+    `import { createApp } from "@cfast/core";`,
+    `import { envSchema } from "./env";`,
+    `import { permissions } from "./permissions";`
+  ];
+  const pluginDefs = [];
+  const useChain = [];
+  if (config.features.auth) {
+    imports.push(`import { definePlugin } from "@cfast/core";`);
+    imports.push(`import { initAuth } from "./auth.setup.server";`);
+    imports.push(`import type { AuthUser } from "./permissions";`);
+    imports.push(`import type { Grant } from "@cfast/permissions";`);
+    pluginDefs.push(`
+const authPlugin = definePlugin({
+  name: "auth",
+  async setup(ctx) {
+    const auth = initAuth({
+      d1: ctx.env.DB as D1Database,
+      appUrl: ctx.env.APP_URL as string,
+    });
+    const authCtx = await auth.createContext(ctx.request);
+    return {
+      user: authCtx.user as AuthUser | null,
+      grants: authCtx.grants as Grant[],
+      instance: auth,
+    };
+  },
+});`);
+    useChain.push("authPlugin");
+  }
+  if (config.features.db) {
+    imports.push(`import { createDb } from "@cfast/db";`);
+    imports.push(`import * as schema from "./db/schema";`);
+    if (config.features.auth) {
+      pluginDefs.push(`
+type AuthProvides = { auth: { user: AuthUser | null; grants: Grant[] } };
+const dbPlugin = definePlugin<AuthProvides>()({
+  name: "db",
+  setup(ctx) {
+    const client = createDb({
+      d1: ctx.env.DB as D1Database,
+      schema: schema as unknown as Record<string, unknown>,
+      grants: ctx.auth.grants,
+      user: ctx.auth.user ? { id: ctx.auth.user.id } : null,
+      cache: false,
+    });
+    return { client };
+  },
+});`);
+    } else {
+      pluginDefs.push(`
+const dbPlugin = definePlugin({
+  name: "db",
+  setup(ctx) {
+    const client = createDb({
+      d1: ctx.env.DB as D1Database,
+      schema: schema as unknown as Record<string, unknown>,
+      grants: [],
+      user: null,
+      cache: false,
+    });
+    return { client };
+  },
+});`);
+    }
+    useChain.push("dbPlugin");
+  }
+  const appLine = useChain.length > 0 ? `export const app = createApp({ env: envSchema, permissions })
+${useChain.map((p) => `  .use(${p})`).join("\n")};` : `export const app = createApp({ env: envSchema, permissions });`;
+  return `${imports.join("\n")}
+${pluginDefs.join("\n")}
+
+${appLine}
+`;
+}
+
+// src/generators/vite-config.ts
+function generateViteConfig(config) {
+  const optimizeDeps = [];
+  if (config.features.ui && config.uiLibrary === "joy") {
+    optimizeDeps.push(`"@cfast/ui/joy"`);
+  }
+  if (config.features.ui) {
+    optimizeDeps.push(`"@cfast/actions/client"`);
+  }
+  if (config.features.auth) {
+    optimizeDeps.push(`"@cfast/auth/client"`);
+  }
+  const optimizeDepsBlock = optimizeDeps.length > 0 ? `
+  optimizeDeps: {
+    include: [
+      ${optimizeDeps.join(",\n      ")},
+    ],
+  },` : "";
+  return `import { reactRouter } from "@react-router/dev/vite";
+import { cloudflare } from "@cloudflare/vite-plugin";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  resolve: {
+    tsconfigPaths: true,
+  },${optimizeDepsBlock}
+  plugins: [
+    cloudflare({ viteEnvironment: { name: "ssr" } }),
+    reactRouter(),
+  ],
+});
+`;
+}
+
+// src/generators/root-tsx.ts
+function generateRootTsx(config) {
+  const imports = [
+    `import {`,
+    `  isRouteErrorResponse,`,
+    `  Links,`,
+    `  Meta,`,
+    `  Outlet,`,
+    `  Scripts,`,
+    `  ScrollRestoration,`,
+    `} from "react-router";`
+  ];
+  let beforeChildren = "";
+  let afterChildren = "";
+  let beforeOutlet = "";
+  let afterOutlet = "";
+  let pluginSetup = "";
+  let errorContent;
+  if (config.features.ui && config.uiLibrary === "joy") {
+    imports.push(`import { CssVarsProvider } from "@mui/joy/styles";`);
+    imports.push(`import CssBaseline from "@mui/joy/CssBaseline";`);
+    imports.push(`import Typography from "@mui/joy/Typography";`);
+    imports.push(`import Container from "@mui/joy/Container";`);
+    imports.push(
+      `import { createUIPlugin, UIPluginProvider, ConfirmProvider } from "@cfast/ui";`
+    );
+    imports.push(`import { ConfirmDialog } from "@cfast/ui/joy";`);
+    pluginSetup = `
+const plugin = createUIPlugin({
+  components: { confirmDialog: ConfirmDialog },
+});
+`;
+    beforeChildren = `        <CssVarsProvider>
+          <CssBaseline />
+          <UIPluginProvider plugin={plugin}>
+            <ConfirmProvider>`;
+    afterChildren = `            </ConfirmProvider>
+          </UIPluginProvider>
+        </CssVarsProvider>`;
+    errorContent = `    <Container sx={{ pt: 8, p: 4 }}>
+      <Typography level="h1">{message}</Typography>
+      <Typography>{details}</Typography>
+      {stack && (
+        <pre style={{ width: "100%", padding: "16px", overflowX: "auto" }}>
+          <code>{stack}</code>
+        </pre>
+      )}
+    </Container>`;
+  } else {
+    errorContent = `    <div style={{ padding: "2rem" }}>
+      <h1>{message}</h1>
+      <p>{details}</p>
+      {stack && (
+        <pre style={{ width: "100%", padding: "16px", overflowX: "auto" }}>
+          <code>{stack}</code>
+        </pre>
+      )}
+    </div>`;
+  }
+  if (config.features.auth) {
+    imports.push(`import { AuthClientProvider } from "@cfast/auth/client";`);
+    imports.push(`import { authClient } from "~/auth.client";`);
+    beforeOutlet = `    <AuthClientProvider authClient={authClient}>`;
+    afterOutlet = `    </AuthClientProvider>`;
+  }
+  const childrenBlock = beforeChildren ? `${beforeChildren}
+              {children}
+${afterChildren}` : `        {children}`;
+  const outletBlock = beforeOutlet ? `${beforeOutlet}
+      <Outlet />
+${afterOutlet}` : `    <Outlet />`;
+  return `${imports.join("\n")}
+${pluginSetup}
+export function Layout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <Meta />
+        <Links />
+      </head>
+      <body>
+${childrenBlock}
+        <ScrollRestoration />
+        <Scripts />
+      </body>
+    </html>
+  );
+}
+
+export default function App() {
+  return (
+${outletBlock}
+  );
+}
+
+export function ErrorBoundary({ error }: { error: unknown }) {
+  let message = "Oops!";
+  let details = "An unexpected error occurred.";
+  let stack: string | undefined;
+
+  if (isRouteErrorResponse(error)) {
+    message = error.status === 404 ? "404" : "Error";
+    details =
+      error.status === 404
+        ? "The requested page could not be found."
+        : error.statusText || details;
+  } else if (import.meta.env.DEV && error && error instanceof Error) {
+    details = error.message;
+    stack = error.stack;
+  }
+
+  return (
+${errorContent}
+  );
+}
+`;
+}
+
+// src/generators/routes-ts.ts
+function generateRoutesTs(config) {
+  const imports = [
+    `import { type RouteConfig, index, route } from "@react-router/dev/routes";`
+  ];
+  const routes = [`  index("routes/_index.tsx"),`];
+  if (config.features.auth) {
+    routes.push(`  route("login", "routes/login.tsx"),`);
+    routes.push(`  route("api/auth/*", "routes/auth.$.tsx"),`);
+  }
+  if (config.features.admin) {
+    routes.push(`  route("admin", "routes/admin.tsx"),`);
+  }
+  return `${imports.join("\n")}
+
+export default [
+${routes.join("\n")}
+] satisfies RouteConfig;
+`;
+}
+
+// src/generators/dev-vars.ts
+function generateDevVars(config) {
+  const lines = [];
+  if (config.features.email) {
+    lines.push(`MAILGUN_API_KEY=test-key`);
+  }
+  if (lines.length === 0) return null;
+  return lines.join("\n") + "\n";
+}
+
+// src/scaffold.ts
+function scaffold(config) {
+  const templatesDir = getTemplatesDir();
+  const targetDir = path2.resolve(process.cwd(), config.targetDir);
+  if (fs2.existsSync(targetDir) && fs2.readdirSync(targetDir).length > 0) {
+    throw new Error(`Directory "${config.targetDir}" already exists and is not empty.`);
+  }
+  copyDir(path2.join(templatesDir, "base"), targetDir);
+  const overlayOrder = ["db", "auth", "storage", "email", "ui", "admin"];
+  const enabledOverlays = overlayOrder.filter((f) => config.features[f]);
+  for (const overlay of enabledOverlays) {
+    const overlayDir = path2.join(templatesDir, overlay);
+    if (fs2.existsSync(overlayDir)) {
+      copyDir(overlayDir, targetDir);
+    }
+  }
+  const basePackageJson = readJsonFragment(path2.join(templatesDir, "base", "package.json"));
+  const overlayFragments = enabledOverlays.map((overlay) => readJsonFragment(path2.join(templatesDir, overlay, "package.json"))).filter((f) => Object.keys(f).length > 0);
+  const mergedPackageJson = mergePackageJsons(
+    basePackageJson,
+    overlayFragments
+  );
+  writeFile(path2.join(targetDir, "package.json"), stringifyPackageJson(mergedPackageJson));
+  writeFile(path2.join(targetDir, "wrangler.toml"), generateWranglerToml(config));
+  writeFile(path2.join(targetDir, "app", "env.ts"), generateEnv(config));
+  writeFile(path2.join(targetDir, "app", "cfast.server.ts"), generateCfastServer(config));
+  writeFile(path2.join(targetDir, "vite.config.ts"), generateViteConfig(config));
+  writeFile(path2.join(targetDir, "app", "root.tsx"), generateRootTsx(config));
+  writeFile(path2.join(targetDir, "app", "routes.ts"), generateRoutesTs(config));
+  const devVars = generateDevVars(config);
+  if (devVars) {
+    writeFile(path2.join(targetDir, ".dev.vars"), devVars);
+  }
+  replaceInDir(targetDir, {
+    projectName: config.projectName
+  });
+}
+
+// src/index.ts
+function printNextSteps(config) {
+  console.log();
+  console.log(green2(`\u2714 Scaffolded ${bold(config.projectName)}/`));
+  console.log();
+  console.log("  Next steps:");
+  console.log(cyan(`    cd ${config.projectName}`));
+  console.log(cyan(`    pnpm install`));
+  console.log(cyan(`    pnpm dev`));
+  if (config.features.db) {
+    console.log();
+    console.log("  Database (D1 + Drizzle):");
+    console.log(cyan(`    pnpm db:generate`));
+    console.log(cyan(`    pnpm db:migrate:local`));
+  }
+  if (config.features.email) {
+    console.log();
+    console.log("  Email:");
+    console.log(`    ${yellow("Edit .dev.vars to set your MAILGUN_API_KEY")}`);
+  }
+  console.log();
+  console.log("  Deploy:");
+  console.log(cyan(`    pnpm deploy:staging`));
+  console.log(cyan(`    pnpm deploy:production`));
+  console.log();
+}
+async function main() {
+  console.log();
+  console.log(bold("  Welcome to cfast!"));
+  console.log();
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  const config = await promptForConfig(args);
+  if (!config) {
+    console.log("Cancelled.");
+    return;
+  }
+  scaffold(config);
+  printNextSteps(config);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "create-cfast",
+  "version": "0.0.1",
+  "description": "Scaffold a fully wired Cloudflare Workers + React Router project with cfast",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DanielMSchmidt/cfast.git",
+    "directory": "packages/create-cfast"
+  },
+  "type": "module",
+  "bin": {
+    "create-cfast": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "dependencies": {
+    "kolorist": "^1",
+    "prompts": "^2"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "@types/prompts": "^2",
+    "tsup": "^8",
+    "typescript": "^5.7",
+    "vitest": "^3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "test": "vitest run"
+  }
+}