@donkeylabs/server 0.3.0 → 0.4.0

package/cli/commands/plugin.ts

@@ -1,192 +0,0 @@
-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.");
-}

package/cli/commands/route.ts

@@ -1,195 +0,0 @@
-/**
- * Route Command
- *
- * Create new routes from the command line
- *
- * Usage:
- *   donkeylabs route <router> <route-name>
- *   donkeylabs route users create
- *   donkeylabs route orders get-by-id
- */
-
-import { writeFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import pc from "picocolors";
-
-function toPascalCase(str: string): string {
-  return str
-    .replace(/-([a-z])/g, (_, c) => c.toUpperCase())
-    .replace(/^./, (c) => c.toUpperCase());
-}
-
-export async function routeCommand(args: string[]): Promise<void> {
-  const routerName = args[0];
-  const routeName = args[1];
-
-  if (!routerName || !routeName) {
-    console.log(`
-${pc.bold("Usage:")}
-  donkeylabs route <router> <route-name>
-
-${pc.bold("Examples:")}
-  donkeylabs route users create
-  donkeylabs route orders get-by-id
-  donkeylabs route health check
-
-${pc.bold("This creates:")}
-  src/routes/<router>/<route-name>/
-    ├── index.ts          # Route definition
-    ├── models/model.ts   # Schema + Model class
-    └── tests/
-        ├── unit.test.ts
-        └── integ.test.ts
-`);
-    process.exit(1);
-  }
-
-  // Validate names
-  if (!/^[a-z][a-z0-9-]*$/.test(routerName)) {
-    console.error(pc.red("Router name must use lowercase letters, numbers, and hyphens"));
-    process.exit(1);
-  }
-
-  if (!/^[a-z][a-z0-9-]*$/.test(routeName)) {
-    console.error(pc.red("Route name must use lowercase letters, numbers, and hyphens"));
-    process.exit(1);
-  }
-
-  const routesDir = join(process.cwd(), "src/routes");
-  const routePath = join(routesDir, routerName, routeName);
-
-  if (existsSync(routePath)) {
-    console.error(pc.red(`Route already exists: src/routes/${routerName}/${routeName}`));
-    process.exit(1);
-  }
-
-  // Create directory structure
-  await mkdir(join(routePath, "models"), { recursive: true });
-  await mkdir(join(routePath, "tests"), { recursive: true });
-
-  // Generate PascalCase and camelCase names
-  const pascalRouter = toPascalCase(routerName);
-  const pascalRoute = toPascalCase(routeName);
-  const camelRoute = routeName.replace(/-([a-z])/g, (_, 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.`));
-}

package/cli/donkeylabs

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-import "./index.ts";

package/cli/index.ts

@@ -1,114 +0,0 @@
-#!/usr/bin/env bun
-/**
- * @donkeylabs/server CLI
- *
- * Commands:
- *   init        Initialize a new project
- *   generate    Generate types (registry, context, client)
- *   plugin      Plugin management (create, list)
- */
-
-import { parseArgs } from "node:util";
-import pc from "picocolors";
-
-const { positionals, values } = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    help: { type: "boolean", short: "h" },
-    version: { type: "boolean", short: "v" },
-  },
-  allowPositionals: true,
-});
-
-const command = positionals[0];
-
-function printHelp() {
-  console.log(`
-${pc.bold("@donkeylabs/server")} - Type-safe plugin system for Bun
-
-${pc.bold("Usage:")}
-  donkeylabs                    Interactive menu
-  donkeylabs <command> [options]
-
-${pc.bold("Commands:")}
-  ${pc.cyan("init")}         Initialize a new project
-  ${pc.cyan("generate")}     Generate types (registry, context, client)
-  ${pc.cyan("route")}        Create a new route
-  ${pc.cyan("dev")}          Start dev server with auto-regeneration
-  ${pc.cyan("plugin")}       Plugin management
-
-${pc.bold("Options:")}
-  -h, --help     Show this help message
-  -v, --version  Show version number
-
-${pc.bold("Examples:")}
-  donkeylabs              # Interactive menu
-  donkeylabs init
-  donkeylabs generate
-  donkeylabs route users create
-  donkeylabs dev
-  donkeylabs plugin create myPlugin
-`);
-}
-
-async function printVersion() {
-  const pkg = await Bun.file(new URL("../package.json", import.meta.url)).json();
-  console.log(pkg.version);
-}
-
-async function main() {
-  if (values.help) {
-    printHelp();
-    process.exit(0);
-  }
-
-  if (values.version) {
-    await printVersion();
-    process.exit(0);
-  }
-
-  // No command provided - launch interactive mode
-  if (!command) {
-    const { interactiveCommand } = await import("./commands/interactive");
-    await interactiveCommand();
-    return;
-  }
-
-  switch (command) {
-    case "init":
-      const { initCommand } = await import("./commands/init");
-      await initCommand(positionals.slice(1));
-      break;
-
-    case "generate":
-    case "gen":
-      const { generateCommand } = await import("./commands/generate");
-      await generateCommand(positionals.slice(1));
-      break;
-
-    case "plugin":
-      const { pluginCommand } = await import("./commands/plugin");
-      await pluginCommand(positionals.slice(1));
-      break;
-
-    case "route":
-      const { routeCommand } = await import("./commands/route");
-      await routeCommand(positionals.slice(1));
-      break;
-
-    case "dev":
-      const { devCommand } = await import("./commands/dev");
-      await devCommand(positionals.slice(1));
-      break;
-
-    default:
-      console.error(pc.red(`Unknown command: ${command}`));
-      console.log(`Run ${pc.cyan("donkeylabs --help")} for available commands.`);
-      process.exit(1);
-  }
-}
-
-main().catch((error) => {
-  console.error(pc.red("Error:"), error.message);
-  process.exit(1);
-});