@donkeylabs/server 0.3.0 → 0.4.0

package/cli/commands/init.ts

@@ -1,205 +0,0 @@
-/**
- * @donkeylabs/server - Init Command
- *
- * Initialize a new project by copying from examples/starter.
- */
-
-import { mkdir, writeFile, readFile, readdir, copyFile, unlink } from "node:fs/promises";
-import { join, resolve, dirname } from "node:path";
-import { existsSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import pc from "picocolors";
-import prompts from "prompts";
-
-interface InitOptions {
-  projectName: string;
-  useDatabase: boolean;
-}
-
-export async function initCommand(args: string[]) {
-  const projectDir = args[0] || ".";
-  const targetDir = resolve(process.cwd(), projectDir);
-
-  console.log(pc.bold("\nInitializing @donkeylabs/server project...\n"));
-
-  // Check for existing files
-  if (existsSync(targetDir)) {
-    const files = await readdir(targetDir);
-    const hasConflicts = files.some(
-      (f) => f === "src" || f === "donkeylabs.config.ts"
-    );
-
-    if (hasConflicts) {
-      const { overwrite } = await prompts({
-        type: "confirm",
-        name: "overwrite",
-        message: "Directory contains existing files. Overwrite?",
-        initial: false,
-      });
-
-      if (!overwrite) {
-        console.log(pc.yellow("Cancelled."));
-        return;
-      }
-    }
-  }
-
-  // Ask for project configuration
-  const responses = await prompts([
-    {
-      type: "text",
-      name: "projectName",
-      message: "Project name:",
-      initial: projectDir === "." ? "my-server" : projectDir,
-    },
-    {
-      type: "confirm",
-      name: "useDatabase",
-      message: "Set up SQLite database?",
-      initial: true,
-    },
-  ]);
-
-  if (!responses.projectName) {
-    console.log(pc.yellow("Cancelled."));
-    return;
-  }
-
-  const options: InitOptions = {
-    projectName: responses.projectName,
-    useDatabase: responses.useDatabase ?? true,
-  };
-
-  // Find the examples/starter directory
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = dirname(__filename);
-  const starterDir = resolve(__dirname, "../../examples/starter");
-  const docsDir = resolve(__dirname, "../../docs");
-
-  if (!existsSync(starterDir)) {
-    console.error(pc.red("Error: examples/starter not found"));
-    return;
-  }
-
-  // Copy starter project
-  await copyDirectory(starterDir, targetDir);
-  console.log(pc.green("  Copied:"), "project files");
-
-  // Replace placeholders in files
-  await replaceInFile(
-    join(targetDir, "package.json"),
-    "{{PROJECT_NAME}}",
-    options.projectName
-  );
-  await replaceInFile(
-    join(targetDir, "CLAUDE.md"),
-    "{{PROJECT_NAME}}",
-    options.projectName
-  );
-
-  // Rename .gitignore.template to .gitignore
-  const gitignoreTemplate = join(targetDir, ".gitignore.template");
-  if (existsSync(gitignoreTemplate)) {
-    const content = await readFile(gitignoreTemplate, "utf-8");
-    await writeFile(join(targetDir, ".gitignore"), content);
-    await unlink(gitignoreTemplate);
-  }
-
-  // If not using database, replace db.ts with dummy driver
-  if (!options.useDatabase) {
-    await writeFile(join(targetDir, "src/db.ts"), generateDummyDb());
-  }
-
-  // Copy docs
-  await mkdir(join(targetDir, "docs"), { recursive: true });
-  await copyDocs(docsDir, join(targetDir, "docs"));
-  console.log(pc.green("  Copied:"), "docs/");
-
-  // Print next steps
-  console.log(`
-${pc.bold(pc.green("Success!"))} Project initialized.
-
-${pc.bold("Next steps:")}
-  1. Install dependencies:
-     ${pc.cyan("bun install")}
-${options.useDatabase ? `
-  2. Set up your database:
-     ${pc.cyan("cp .env.example .env")}
-` : ""}
-  ${options.useDatabase ? "3" : "2"}. Start development:
-     ${pc.cyan("bun run dev")}
-
-  Run tests:
-     ${pc.cyan("bun test")}
-`);
-}
-
-async function copyDirectory(src: string, dest: string) {
-  await mkdir(dest, { recursive: true });
-  const entries = await readdir(src, { withFileTypes: true });
-
-  for (const entry of entries) {
-    const srcPath = join(src, entry.name);
-    const destPath = join(dest, entry.name);
-
-    if (entry.isDirectory()) {
-      await copyDirectory(srcPath, destPath);
-    } else {
-      await copyFile(srcPath, destPath);
-    }
-  }
-}
-
-async function replaceInFile(filePath: string, search: string, replace: string) {
-  if (!existsSync(filePath)) return;
-  const content = await readFile(filePath, "utf-8");
-  await writeFile(filePath, content.replaceAll(search, replace));
-}
-
-async function copyDocs(src: string, dest: string) {
-  const docs = [
-    "plugins.md",
-    "router.md",
-    "handlers.md",
-    "core-services.md",
-    "errors.md",
-    "cache.md",
-    "logger.md",
-    "events.md",
-    "jobs.md",
-    "cron.md",
-    "sse.md",
-    "rate-limiter.md",
-    "middleware.md",
-    "api-client.md",
-    "svelte-frontend.md",
-  ];
-
-  for (const doc of docs) {
-    const srcPath = join(src, doc);
-    if (existsSync(srcPath)) {
-      await copyFile(srcPath, join(dest, doc));
-    }
-  }
-}
-
-function generateDummyDb(): string {
-  return `import {
-  Kysely,
-  DummyDriver,
-  SqliteAdapter,
-  SqliteIntrospector,
-  SqliteQueryCompiler,
-} from "kysely";
-
-// No database configured - using dummy driver for type compatibility
-export const db = new Kysely<any>({
-  dialect: {
-    createAdapter: () => new SqliteAdapter(),
-    createDriver: () => new DummyDriver(),
-    createIntrospector: (db) => new SqliteIntrospector(db),
-    createQueryCompiler: () => new SqliteQueryCompiler(),
-  },
-});
-`;
-}

package/cli/commands/interactive.ts

@@ -1,417 +0,0 @@
-/**
- * Interactive CLI Menu
- *
- * Full interactive experience with context-aware menus
- */
-
-import prompts from "prompts";
-import pc from "picocolors";
-import { readdir, writeFile, mkdir } from "node:fs/promises";
-import { join, basename } from "node:path";
-import { existsSync } from "node:fs";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-
-const execAsync = promisify(exec);
-
-export async function interactiveCommand() {
-  console.clear();
-  console.log(pc.magenta(pc.bold("\n  @donkeylabs/server CLI\n")));
-
-  // Detect context - are we in a plugin directory?
-  const cwd = process.cwd();
-  const pathParts = cwd.split("/");
-  const parentDir = pathParts[pathParts.length - 2];
-  const currentDir = pathParts[pathParts.length - 1];
-
-  let contextPlugin: string | null = null;
-  if (parentDir === "plugins" && currentDir && existsSync(join(cwd, "index.ts"))) {
-    contextPlugin = currentDir;
-  }
-
-  // Run appropriate menu loop
-  if (contextPlugin) {
-    await pluginMenuLoop(contextPlugin);
-  } else {
-    await globalMenuLoop();
-  }
-}
-
-// ============================================
-// Plugin Context Menu (Inside plugins/<name>/)
-// ============================================
-
-async function pluginMenuLoop(pluginName: string) {
-  while (true) {
-    console.log(pc.cyan(`\n  Context: Plugin ${pc.bold(`'${pluginName}'`)}\n`));
-
-    const response = await prompts({
-      type: "select",
-      name: "action",
-      message: "What would you like to do?",
-      choices: [
-        { title: pc.yellow("1.") + " Generate Schema Types", value: "gen-types" },
-        { title: pc.yellow("2.") + " Create Migration", value: "migration" },
-        { title: pc.gray("─".repeat(35)), value: "separator", disabled: true },
-        { title: pc.blue("←") + "  Back to Global Menu", value: "global" },
-        { title: pc.red("×") + "  Exit", value: "exit" },
-      ],
-    });
-
-    if (!response.action || response.action === "exit") {
-      console.log(pc.gray("\nGoodbye!\n"));
-      process.exit(0);
-    }
-
-    if (response.action === "global") {
-      console.clear();
-      console.log(pc.magenta(pc.bold("\n  @donkeylabs/server CLI\n")));
-      await globalMenuLoop();
-      return;
-    }
-
-    console.log(""); // spacing
-
-    switch (response.action) {
-      case "gen-types":
-        await runCommand(`bun scripts/generate-types.ts ${pluginName}`);
-        break;
-      case "migration":
-        await createMigration(pluginName);
-        break;
-    }
-
-    await pressEnterToContinue();
-  }
-}
-
-// ============================================
-// Global Root Menu
-// ============================================
-
-async function globalMenuLoop() {
-  while (true) {
-    console.log(pc.cyan("\n  Context: Project Root\n"));
-
-    const choices = [
-      { title: pc.yellow("1.") + " Add Route", value: "add-route" },
-      { title: pc.yellow("2.") + " Create New Plugin", value: "new-plugin" },
-      { title: pc.yellow("3.") + " Initialize New Project", value: "init" },
-      { title: pc.gray("─".repeat(35)), value: "separator1", disabled: true },
-      { title: pc.yellow("4.") + " Generate Types", value: "generate" },
-      { title: pc.yellow("5.") + " Generate Registry", value: "gen-registry" },
-      { title: pc.yellow("6.") + " Generate Server Context", value: "gen-server" },
-      { title: pc.gray("─".repeat(35)), value: "separator2", disabled: true },
-      { title: pc.red("×") + "  Exit", value: "exit" },
-    ];
-
-    const response = await prompts({
-      type: "select",
-      name: "action",
-      message: "Select a command:",
-      choices,
-    });
-
-    if (!response.action || response.action === "exit") {
-      console.log(pc.gray("\nGoodbye!\n"));
-      process.exit(0);
-    }
-
-    console.log(""); // spacing
-
-    switch (response.action) {
-      case "add-route":
-        await addRoute();
-        break;
-      case "new-plugin":
-        const { pluginCommand } = await import("./plugin");
-        await pluginCommand(["create"]);
-        break;
-      case "init":
-        const { initCommand } = await import("./init");
-        await initCommand([]);
-        break;
-      case "generate":
-        const { generateCommand } = await import("./generate");
-        await generateCommand([]);
-        break;
-      case "gen-registry":
-        await runCommand("bun scripts/generate-registry.ts");
-        break;
-      case "gen-server":
-        await runCommand("bun scripts/generate-server.ts");
-        break;
-    }
-
-    await pressEnterToContinue();
-  }
-}
-
-// ============================================
-// Commands
-// ============================================
-
-async function addRoute() {
-  const routesDir = join(process.cwd(), "src/routes");
-
-  // Find existing routers (namespace directories)
-  let existingRouters: string[] = [];
-  if (existsSync(routesDir)) {
-    const entries = await readdir(routesDir, { withFileTypes: true });
-    existingRouters = entries
-      .filter((e) => e.isDirectory() && !e.name.startsWith("."))
-      .map((e) => e.name);
-  }
-
-  // Choose router
-  const routerChoices = [
-    ...existingRouters.map((r) => ({ title: r, value: r })),
-    { title: pc.green("+ Create new router"), value: "__new__" },
-  ];
-
-  const routerRes = await prompts({
-    type: "select",
-    name: "router",
-    message: "Select router (namespace):",
-    choices: routerChoices,
-  });
-
-  if (!routerRes.router) return;
-
-  let routerName = routerRes.router;
-  if (routerName === "__new__") {
-    const newRouterRes = await prompts({
-      type: "text",
-      name: "name",
-      message: "Router name (e.g. users, orders):",
-      validate: (v) =>
-        /^[a-z][a-z0-9-]*$/.test(v) ? true : "Use lowercase letters, numbers, and hyphens",
-    });
-    if (!newRouterRes.name) return;
-    routerName = newRouterRes.name;
-  }
-
-  // Get route name
-  const routeRes = await prompts({
-    type: "text",
-    name: "name",
-    message: "Route name (e.g. create, get-by-id):",
-    validate: (v) =>
-      /^[a-z][a-z0-9-]*$/.test(v) ? true : "Use lowercase letters, numbers, and hyphens",
-  });
-
-  if (!routeRes.name) return;
-
-  const routeName = routeRes.name;
-  const routePath = join(routesDir, routerName, routeName);
-
-  // Create directory structure
-  await mkdir(join(routePath, "models"), { recursive: true });
-  await mkdir(join(routePath, "tests"), { recursive: true });
-
-  // Generate PascalCase names
-  const pascalRouter = toPascalCase(routerName);
-  const pascalRoute = toPascalCase(routeName);
-  const camelRoute = routeName.replace(/-([a-z])/g, (_: string, c: string) => c.toUpperCase());
-
-  // Create model.ts with Model class
-  const modelContent = `import { z } from "zod";
-
-// After running \`donkeylabs generate\`, use typed Handler:
-// import type { Handler } from "@donkeylabs/server";
-// import type { ${pascalRouter} } from "$server/routes";
-// export class ${pascalRoute}Model implements Handler<${pascalRouter}.${pascalRoute}> { ... }
-
-// Input/Output schemas
-export const Input = z.object({
-  // Define your input schema here
-});
-
-export const Output = z.object({
-  success: z.boolean(),
-});
-
-export type Input = z.infer<typeof Input>;
-export type Output = z.infer<typeof Output>;
-
-/**
- * Model class with handler logic.
- * After gen:types, implement Handler<${pascalRouter}.${pascalRoute}> for full typing.
- */
-export class ${pascalRoute}Model {
-  constructor(private ctx: any) {}
-
-  handle(input: Input): Output {
-    return {
-      success: true,
-    };
-  }
-}
-`;
-  await writeFile(join(routePath, "models/model.ts"), modelContent);
-
-  // Create index.ts (route definition)
-  const routeIndexContent = `// Route definition
-// After gen:types, use: Route<${pascalRouter}.${pascalRoute}> for full typing
-import type { AppRoute } from "@donkeylabs/server";
-import { Input, Output, ${pascalRoute}Model } from "./models/model";
-
-export const ${camelRoute}Route: AppRoute = {
-  input: Input,
-  output: Output,
-  handle: async (input, ctx) => {
-    const model = new ${pascalRoute}Model(ctx);
-    return model.handle(input);
-  },
-};
-`;
-  await writeFile(join(routePath, "index.ts"), routeIndexContent);
-
-  // Create unit.test.ts
-  const unitTestContent = `import { describe, it, expect } from "bun:test";
-import { ${pascalRoute}Model, Input } from "../models/model";
-
-describe("${routerName}.${routeName} model", () => {
-  it("should return success", () => {
-    const input = Input.parse({});
-    const ctx = {} as any;
-    const model = new ${pascalRoute}Model(ctx);
-    const result = model.handle(input);
-    expect(result.success).toBe(true);
-  });
-});
-`;
-  await writeFile(join(routePath, "tests/unit.test.ts"), unitTestContent);
-
-  // Create integ.test.ts
-  const integTestContent = `import { describe, it, expect } from "bun:test";
-
-const BASE_URL = process.env.TEST_SERVER_URL || "http://localhost:3000";
-
-describe("${routerName}.${routeName} (integration)", () => {
-  // Server must be running for integration tests
-  it("POST /${routerName}.${routeName} returns success", async () => {
-    try {
-      const res = await fetch(\`\${BASE_URL}/${routerName}.${routeName}\`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({}),
-      });
-      expect(res.ok).toBe(true);
-    } catch (e: any) {
-      if (e.code === "ConnectionRefused") {
-        console.log("Skipping: Server not running");
-        return;
-      }
-      throw e;
-    }
-  });
-});
-`;
-  await writeFile(join(routePath, "tests/integ.test.ts"), integTestContent);
-
-  // Check if router index exists, if not create it
-  const routerIndexPath = join(routesDir, routerName, "index.ts");
-  if (!existsSync(routerIndexPath)) {
-    const routerIndexContent = `import { createRouter } from "@donkeylabs/server";
-import { ${camelRoute}Route } from "./${routeName}";
-
-export const ${camelRoute}Router = createRouter("${routerName}")
-  .route("${routeName}").typed(${camelRoute}Route);
-`;
-    await writeFile(routerIndexPath, routerIndexContent);
-    console.log(pc.green(`Created router: src/routes/${routerName}/index.ts`));
-  } else {
-    console.log(pc.yellow(`\nNote: Add the route to src/routes/${routerName}/index.ts:`));
-    console.log(pc.gray(`  import { ${camelRoute}Route } from "./${routeName}";`));
-    console.log(pc.gray(`  .route("${routeName}").typed(${camelRoute}Route)`));
-  }
-
-  console.log(pc.green(`\nCreated route: src/routes/${routerName}/${routeName}/`));
-  console.log(pc.gray(`  - index.ts`));
-  console.log(pc.gray(`  - models/model.ts`));
-  console.log(pc.gray(`  - tests/unit.test.ts`));
-  console.log(pc.gray(`  - tests/integ.test.ts`));
-  console.log(pc.cyan(`\nRun ${pc.bold("donkeylabs generate")} to update types.`));
-}
-
-function toPascalCase(str: string): string {
-  return str
-    .replace(/-([a-z])/g, (_, c) => c.toUpperCase())
-    .replace(/^./, (c) => c.toUpperCase());
-}
-
-async function createMigration(pluginName: string) {
-  const nameRes = await prompts({
-    type: "text",
-    name: "migName",
-    message: "Migration name (e.g. add_comments):",
-    validate: (v) =>
-      /^[a-z0-9_]+$/.test(v) ? true : "Use lowercase letters, numbers, and underscores",
-  });
-
-  if (!nameRes.migName) return;
-
-  // Determine migrations directory
-  const cwd = process.cwd();
-  const isPluginDir = basename(join(cwd, "..")) === "plugins";
-  const migrationsDir = isPluginDir
-    ? join(cwd, "migrations")
-    : join(process.cwd(), "src/plugins", pluginName, "migrations");
-
-  // Generate sequential number
-  let nextNum = 1;
-  try {
-    const files = await readdir(migrationsDir);
-    const nums = files
-      .map((f) => parseInt(f.split("_")[0] || "", 10))
-      .filter((n) => !isNaN(n));
-    if (nums.length > 0) {
-      nextNum = Math.max(...nums) + 1;
-    }
-  } catch {}
-
-  const filename = `${String(nextNum).padStart(3, "0")}_${nameRes.migName}.ts`;
-  const content = `import type { Kysely } from "kysely";
-
-export async function up(db: Kysely<any>): Promise<void> {
-  // await db.schema.createTable("...").execute();
-}
-
-export async function down(db: Kysely<any>): Promise<void> {
-  // await db.schema.dropTable("...").execute();
-}
-`;
-
-  if (!existsSync(migrationsDir)) {
-    await mkdir(migrationsDir, { recursive: true });
-  }
-
-  await writeFile(join(migrationsDir, filename), content);
-  console.log(pc.green(`Created migration: ${filename}`));
-}
-
-// ============================================
-// Helpers
-// ============================================
-
-async function runCommand(cmd: string) {
-  console.log(pc.gray(`> ${cmd}\n`));
-  try {
-    const { stdout, stderr } = await execAsync(cmd);
-    if (stdout) console.log(stdout);
-    if (stderr) console.error(pc.yellow(stderr));
-  } catch (e: any) {
-    console.error(pc.red("Command failed:"), e.message);
-  }
-}
-
-async function pressEnterToContinue() {
-  await prompts({
-    type: "invisible",
-    name: "continue",
-    message: pc.gray("Press Enter to continue..."),
-  });
-  console.clear();
-  console.log(pc.magenta(pc.bold("\n  @donkeylabs/server CLI\n")));
-}