@donkeylabs/server 0.1.0

package/cli/commands/init.ts

@@ -0,0 +1,287 @@
+/**
+ * Init Command
+ *
+ * Initialize a new @donkeylabs/server project with proper database setup.
+ */
+
+import { mkdir, writeFile, readFile, readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import pc from "picocolors";
+import prompts from "prompts";
+
+interface InitOptions {
+  projectName: string;
+  useDatabase: boolean;
+}
+
+export async function initCommand(args: string[]): Promise<void> {
+  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,
+  };
+
+  // Create directories
+  await mkdir(join(targetDir, "src/plugins"), { recursive: true });
+  await mkdir(join(targetDir, ".@donkeylabs/server"), { recursive: true });
+
+  // Create config file
+  await writeFile(
+    join(targetDir, "donkeylabs.config.ts"),
+    generateConfig()
+  );
+  console.log(pc.green("  Created:"), "donkeylabs.config.ts");
+
+  // Create database setup file if using SQLite
+  if (options.useDatabase) {
+    await writeFile(join(targetDir, "src/db.ts"), generateDatabaseSetup());
+    console.log(pc.green("  Created:"), "src/db.ts");
+
+    await writeFile(join(targetDir, ".env.example"), generateEnvExample());
+    console.log(pc.green("  Created:"), ".env.example");
+  }
+
+  // Create main index file
+  await writeFile(
+    join(targetDir, "src/index.ts"),
+    generateIndexFile(options.useDatabase)
+  );
+  console.log(pc.green("  Created:"), "src/index.ts");
+
+  // Update .gitignore
+  const gitignorePath = join(targetDir, ".gitignore");
+  const gitignoreContent = existsSync(gitignorePath)
+    ? await readFile(gitignorePath, "utf-8")
+    : "";
+
+  const gitignoreAdditions: string[] = [];
+  if (!gitignoreContent.includes(".@donkeylabs")) {
+    gitignoreAdditions.push("# Generated types", ".@donkeylabs/");
+  }
+  if (!gitignoreContent.includes(".env") && options.useDatabase) {
+    gitignoreAdditions.push("# Environment", ".env", ".env.local");
+  }
+  if (options.useDatabase && !gitignoreContent.includes("*.db")) {
+    gitignoreAdditions.push("# SQLite", "*.db", "*.db-journal");
+  }
+
+  if (gitignoreAdditions.length > 0) {
+    const newGitignore = gitignoreContent + "\n" + gitignoreAdditions.join("\n") + "\n";
+    await writeFile(gitignorePath, newGitignore);
+    console.log(pc.green("  Updated:"), ".gitignore");
+  }
+
+  // Create tsconfig.json if not exists
+  if (!existsSync(join(targetDir, "tsconfig.json"))) {
+    await writeFile(
+      join(targetDir, "tsconfig.json"),
+      generateTsConfig()
+    );
+    console.log(pc.green("  Created:"), "tsconfig.json");
+  }
+
+  // Update package.json
+  const pkgPath = join(targetDir, "package.json");
+  let pkg: any = { name: options.projectName, type: "module", scripts: {} };
+
+  if (existsSync(pkgPath)) {
+    pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    pkg.scripts = pkg.scripts || {};
+  }
+
+  pkg.name = pkg.name || options.projectName;
+  pkg.type = "module";
+  pkg.scripts.dev = "bun --watch src/index.ts";
+  pkg.scripts.start = "bun src/index.ts";
+  pkg.scripts["gen:types"] = "donkeylabs generate";
+
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+  console.log(pc.green("  Updated:"), "package.json");
+
+  // Print next steps
+  console.log(`
+${pc.bold(pc.green("Success!"))} Project initialized.
+
+${pc.bold("Next steps:")}
+  1. Install dependencies:
+     ${pc.cyan(getDependencyCommand(options.useDatabase))}
+${options.useDatabase ? `
+  2. Set up your database:
+     ${pc.cyan(`cp .env.example .env`)}
+     ${pc.dim("# Edit .env with your database path")}
+` : ""}
+  ${options.useDatabase ? "3" : "2"}. Start development:
+     ${pc.cyan("bun run dev")}
+
+  ${options.useDatabase ? "4" : "3"}. Generate types after adding plugins:
+     ${pc.cyan("bun run gen:types")}
+`);
+}
+
+function generateConfig(): string {
+  return `import { defineConfig } from "@donkeylabs/server";
+
+export default defineConfig({
+  plugins: ["./src/plugins/**/index.ts"],
+  outDir: ".@donkeylabs/server",
+});
+`;
+}
+
+function generateDatabaseSetup(): string {
+  return `import { Kysely } from "kysely";
+import { BunSqliteDialect } from "kysely-bun-sqlite";
+import { Database } from "bun:sqlite";
+
+const dbPath = process.env.DATABASE_URL || "app.db";
+
+export const db = new Kysely<any>({
+  dialect: new BunSqliteDialect({
+    database: new Database(dbPath),
+  }),
+});
+
+export type DB = typeof db;
+`;
+}
+
+function generateIndexFile(useDatabase: boolean): string {
+  const dbImport = useDatabase
+    ? `import { db } from "./db";\n`
+    : `import {
+  Kysely,
+  DummyDriver,
+  SqliteAdapter,
+  SqliteIntrospector,
+  SqliteQueryCompiler,
+} from "kysely";
+
+// No database configured - using dummy driver for type compatibility
+const db = new Kysely<any>({
+  dialect: {
+    createAdapter: () => new SqliteAdapter(),
+    createDriver: () => new DummyDriver(),
+    createIntrospector: (db) => new SqliteIntrospector(db),
+    createQueryCompiler: () => new SqliteQueryCompiler(),
+  },
+});
+`;
+
+  return `${dbImport}import { AppServer, createRouter } from "@donkeylabs/server";
+import { z } from "zod";
+
+// Create Server
+const server = new AppServer({
+  port: Number(process.env.PORT) || 3000,
+  db,
+  config: { env: process.env.NODE_ENV || "development" },
+});
+
+// Define Routes
+const router = createRouter("api")
+  .route("hello").typed({
+    input: z.object({ name: z.string().optional() }),
+    output: z.object({ message: z.string() }),
+    handle: async (input) => {
+      return { message: \`Hello, \${input.name || "World"}!\` };
+    },
+  })
+  .route("health").raw({
+    handle: async () => {
+      return Response.json({ status: "ok", timestamp: new Date().toISOString() });
+    },
+  });
+
+server.use(router);
+
+// Start Server
+await server.start();
+`;
+}
+
+function generateEnvExample(): string {
+  return `# Database (SQLite file path)
+DATABASE_URL=app.db
+
+# Server
+PORT=3000
+NODE_ENV=development
+`;
+}
+
+function generateTsConfig(): string {
+  return `{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true
+  },
+  "include": ["src/**/*", "*.ts", ".@donkeylabs/**/*"]
+}
+`;
+}
+
+function getDependencyCommand(useDatabase: boolean): string {
+  const base = "bun add @donkeylabs/server kysely zod";
+  return useDatabase ? `${base} kysely-bun-sqlite` : base;
+}

package/cli/commands/interactive.ts

@@ -0,0 +1,223 @@
+/**
+ * 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.") + " Create New Plugin", value: "new-plugin" },
+      { title: pc.yellow("2.") + " Initialize New Project", value: "init" },
+      { title: pc.gray("─".repeat(35)), value: "separator1", disabled: true },
+      { title: pc.yellow("3.") + " Generate Types", value: "generate" },
+      { title: pc.yellow("4.") + " Generate Registry", value: "gen-registry" },
+      { title: pc.yellow("5.") + " 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 "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 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")));
+}

package/cli/commands/plugin.ts

@@ -0,0 +1,192 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import pc from "picocolors";
+import prompts from "prompts";
+
+export async function pluginCommand(args: string[]): Promise<void> {
+  const subcommand = args[0];
+
+  switch (subcommand) {
+    case "create":
+    case "new":
+      await createPlugin(args[1]);
+      break;
+
+    case "list":
+      await listPlugins();
+      break;
+
+    default:
+      console.log(`
+${pc.bold("Plugin Management")}
+
+${pc.bold("Commands:")}
+  ${pc.cyan("create <name>")}    Create a new plugin
+  ${pc.cyan("list")}             List installed plugins
+
+${pc.bold("Examples:")}
+  donkeylabs plugin create auth
+  donkeylabs plugin list
+`);
+  }
+}
+
+async function createPlugin(name?: string): Promise<void> {
+  if (!name) {
+    const response = await prompts({
+      type: "text",
+      name: "name",
+      message: "Plugin name:",
+      validate: (v) =>
+        /^[a-z][a-z0-9-]*$/.test(v) ||
+        "Name must be lowercase alphanumeric with dashes",
+    });
+    name = response.name;
+  }
+
+  if (!name) {
+    console.log(pc.yellow("Cancelled."));
+    return;
+  }
+
+  const { hasSchema, hasDependencies } = await prompts([
+    {
+      type: "confirm",
+      name: "hasSchema",
+      message: "Does this plugin need a database schema?",
+      initial: false,
+    },
+    {
+      type: "confirm",
+      name: "hasDependencies",
+      message: "Does this plugin depend on other plugins?",
+      initial: false,
+    },
+  ]);
+
+  let dependencies: string[] = [];
+  if (hasDependencies) {
+    const { deps } = await prompts({
+      type: "list",
+      name: "deps",
+      message: "Enter dependency names (comma-separated):",
+      separator: ",",
+    });
+    dependencies = deps?.filter(Boolean) || [];
+  }
+
+  const pluginDir = join(process.cwd(), "src/plugins", name);
+
+  if (existsSync(pluginDir)) {
+    console.log(pc.red(`Plugin directory already exists: ${pluginDir}`));
+    return;
+  }
+
+  await mkdir(pluginDir, { recursive: true });
+
+  const camelName = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+  const pascalName = camelName.charAt(0).toUpperCase() + camelName.slice(1);
+
+  const schemaImport = hasSchema
+    ? `import type { DB as ${pascalName}Schema } from "./schema";\n`
+    : "";
+
+  const schemaType = hasSchema ? `<${pascalName}Schema>()` : "";
+
+  const depsLine =
+    dependencies.length > 0
+      ? `  dependencies: [${dependencies.map((d) => `"${d}"`).join(", ")}] as const,\n`
+      : "";
+
+  const pluginContent = `import { createPlugin } from "@donkeylabs/server";
+${schemaImport}
+export interface ${pascalName}Service {
+  // Define your service interface here
+  getData(): Promise<string>;
+}
+
+export const ${camelName}Plugin = createPlugin${hasSchema ? `\n  .withSchema${schemaType}` : ""}
+  .define({
+    name: "${name}",
+    version: "1.0.0",
+${depsLine}
+    service: async (ctx): Promise<${pascalName}Service> => {
+      console.log("[${pascalName}Plugin] Initializing...");
+${
+  dependencies.length > 0
+    ? dependencies.map((d) => `      // Access ${d} via: ctx.deps.${d}`).join("\n") + "\n"
+    : ""
+}
+      return {
+        getData: async () => {
+          return "Hello from ${name} plugin!";
+        },
+      };
+    },
+  });
+`;
+
+  await writeFile(join(pluginDir, "index.ts"), pluginContent);
+  console.log(pc.green("  Created:"), `src/plugins/${name}/index.ts`);
+
+  if (hasSchema) {
+    const schemaContent = `// Database schema types for ${name} plugin
+// Run \`bun run gen:types\` to regenerate from database
+
+export interface DB {
+  // Define your table interfaces here
+  // Example:
+  // ${name}: {
+  //   id: Generated<number>;
+  //   name: string;
+  //   created_at: Generated<string>;
+  // };
+}
+`;
+    await writeFile(join(pluginDir, "schema.ts"), schemaContent);
+    console.log(pc.green("  Created:"), `src/plugins/${name}/schema.ts`);
+
+    await mkdir(join(pluginDir, "migrations"), { recursive: true });
+
+    const migrationContent = `import { Kysely } from "kysely";
+
+export async function up(db: Kysely<any>) {
+  // Create your tables here
+  // await db.schema
+  //   .createTable("${name}")
+  //   .ifNotExists()
+  //   .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
+  //   .addColumn("name", "text", (col) => col.notNull())
+  //   .addColumn("created_at", "text", (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))
+  //   .execute();
+}
+
+export async function down(db: Kysely<any>) {
+  // Drop your tables here
+  // await db.schema.dropTable("${name}").ifExists().execute();
+}
+`;
+    await writeFile(
+      join(pluginDir, "migrations", "001_initial.ts"),
+      migrationContent
+    );
+    console.log(
+      pc.green("  Created:"),
+      `src/plugins/${name}/migrations/001_initial.ts`
+    );
+  }
+
+  console.log(`
+${pc.bold(pc.green("Plugin created!"))}
+
+${pc.bold("Next steps:")}
+  1. Edit your plugin at ${pc.cyan(`src/plugins/${name}/index.ts`)}
+${hasSchema ? `  2. Define your schema in ${pc.cyan(`src/plugins/${name}/schema.ts`)}\n  3. Add migrations in ${pc.cyan(`src/plugins/${name}/migrations/`)}\n` : ""}  ${hasSchema ? "4" : "2"}. Regenerate types: ${pc.cyan("donkeylabs generate")}
+`);
+}
+
+async function listPlugins() {
+  console.log(pc.yellow("Plugin listing not yet implemented."));
+  console.log("Run 'donkeylabs generate' to see discovered plugins.");
+}