@donkeylabs/server 0.2.9 → 0.2.11

package/examples/starter/node_modules/@donkeylabs/server/cli/commands/generate.ts

@@ -1,445 +0,0 @@
-import { readdir, writeFile, readFile, mkdir } from "node:fs/promises";
-import { join, relative, dirname, basename } from "node:path";
-import { existsSync } from "node:fs";
-import pc from "picocolors";
-
-interface DonkeylabsConfig {
-  plugins: string[];
-  outDir?: string;
-  client?: {
-    output: string;
-  };
-  routes?: string; // Route files pattern, default: "./src/routes/**/handler.ts"
-}
-
-async function loadConfig(): Promise<DonkeylabsConfig> {
-  const configPath = join(process.cwd(), "donkeylabs.config.ts");
-
-  if (!existsSync(configPath)) {
-    throw new Error("donkeylabs.config.ts not found. Run 'donkeylabs init' first.");
-  }
-
-  const config = await import(configPath);
-  return config.default;
-}
-
-async function getPluginExportName(pluginPath: string): Promise<string | null> {
-  try {
-    const content = await readFile(pluginPath, "utf-8");
-    const match = content.match(/export\s+const\s+(\w+Plugin)\s*=/);
-    return match?.[1] ?? null;
-  } catch {
-    return null;
-  }
-}
-
-async function extractHandlerNames(pluginPath: string): Promise<string[]> {
-  try {
-    const content = await readFile(pluginPath, "utf-8");
-    const handlersMatch = content.match(/handlers:\s*\{([^}]+)\}/);
-    if (!handlersMatch?.[1]) return [];
-
-    const handlersBlock = handlersMatch[1];
-    return [...handlersBlock.matchAll(/(\w+)\s*:/g)]
-      .map((m) => m[1])
-      .filter((name): name is string => !!name);
-  } catch {
-    return [];
-  }
-}
-
-async function extractMiddlewareNames(pluginPath: string): Promise<string[]> {
-  try {
-    const content = await readFile(pluginPath, "utf-8");
-    const middlewareMatch = content.match(/middleware:\s*\{([^}]+)\}/);
-    if (!middlewareMatch?.[1]) return [];
-
-    const middlewareBlock = middlewareMatch[1];
-    return [...middlewareBlock.matchAll(/(\w+)\s*:/g)]
-      .map((m) => m[1])
-      .filter((name): name is string => !!name);
-  } catch {
-    return [];
-  }
-}
-
-
-async function findPlugins(
-  patterns: string[]
-): Promise<{ name: string; path: string; exportName: string }[]> {
-  const plugins: { name: string; path: string; exportName: string }[] = [];
-
-  for (const pattern of patterns) {
-    const baseDir = pattern.includes("**")
-      ? pattern.split("**")[0] || "."
-      : dirname(pattern);
-
-    const targetDir = join(process.cwd(), baseDir);
-    if (!existsSync(targetDir)) continue;
-
-    async function scanDir(dir: string): Promise<void> {
-      const entries = await readdir(dir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-          await scanDir(fullPath);
-        } else if (entry.name === "index.ts") {
-          const exportName = await getPluginExportName(fullPath);
-          if (exportName) {
-            const pluginName = dirname(fullPath).split("/").pop()!;
-            plugins.push({
-              name: pluginName,
-              path: relative(process.cwd(), fullPath),
-              exportName,
-            });
-          }
-        }
-      }
-    }
-
-    await scanDir(targetDir);
-  }
-
-  return plugins;
-}
-
-export async function generateCommand(_args: string[]): Promise<void> {
-  const config = await loadConfig();
-  const outDir = config.outDir || ".@donkeylabs/server";
-  const outPath = join(process.cwd(), outDir);
-
-  await mkdir(outPath, { recursive: true });
-
-  const plugins = await findPlugins(config.plugins);
-  const routes = await findRoutes(config.routes || "./src/routes/**/schema.ts");
-
-  // Generate all files
-  await generateRegistry(plugins, outPath);
-  await generateContext(plugins, outPath);
-  await generateRouteTypes(routes, outPath);
-
-  const generated = ["registry", "context", "routes"];
-
-  if (config.client?.output) {
-    await generateClient(routes, plugins, config.client.output);
-    generated.push("client");
-  }
-
-  console.log(pc.green("Generated:"), generated.map(g => pc.dim(g)).join(", "));
-}
-
-async function generateRegistry(
-  plugins: { name: string; path: string; exportName: string }[],
-  outPath: string
-) {
-  const importLines = plugins
-    .map(
-      (p) =>
-        `import { ${p.exportName} } from "${join(process.cwd(), p.path).replace(/\.ts$/, "")}";`
-    )
-    .join("\n");
-
-  const pluginRegistryEntries = plugins
-    .map(
-      (p) =>
-        `    ${p.name}: Register<InferService<typeof ${p.exportName}>, InferSchema<typeof ${p.exportName}>, InferHandlers<typeof ${p.exportName}>, InferDependencies<typeof ${p.exportName}>, InferMiddleware<typeof ${p.exportName}>>;`
-    )
-    .join("\n");
-
-  const handlerExtensions =
-    plugins.map((p) => `InferHandlers<typeof ${p.exportName}>`).join(",\n    ") ||
-    "{}";
-
-  const middlewareExtensions =
-    plugins
-      .map((p) => `InferMiddleware<typeof ${p.exportName}>`)
-      .join(",\n    ") || "{}";
-
-  // Collect handlers and middleware from each plugin
-  const allHandlers: { plugin: string; handler: string }[] = [];
-  const allMiddleware: { plugin: string; middleware: string }[] = [];
-
-  for (const p of plugins) {
-    const handlers = await extractHandlerNames(join(process.cwd(), p.path));
-    const middleware = await extractMiddlewareNames(join(process.cwd(), p.path));
-
-    for (const h of handlers) {
-      allHandlers.push({ plugin: p.exportName, handler: h });
-    }
-    for (const m of middleware) {
-      allMiddleware.push({ plugin: p.exportName, middleware: m });
-    }
-  }
-
-  const routeBuilderMethods = allHandlers
-    .map(
-      ({ plugin, handler }) => `    /** Custom handler from ${plugin} */
-    ${handler}(config: {
-      handle: InferHandlers<typeof ${plugin}>["${handler}"]["__signature"];
-    }): TRouter;`
-    )
-    .join("\n");
-
-  const handlerUnion =
-    allHandlers.length > 0
-      ? `"typed" | "raw" | ${allHandlers.map((h) => `"${h.handler}"`).join(" | ")}`
-      : '"typed" | "raw"';
-
-  const middlewareUnion =
-    allMiddleware.length > 0
-      ? allMiddleware.map((m) => `"${m.middleware}"`).join(" | ")
-      : "never";
-
-  // Router middleware methods (returns IRouter for chaining)
-  const middlewareBuilderMethods = allMiddleware
-    .map(
-      ({ plugin, middleware }) => `    /** Middleware from ${plugin} */
-    ${middleware}(config?: InferMiddleware<typeof ${plugin}>["${middleware}"]["__config"]): TRouter;`
-    )
-    .join("\n");
-
-  const content = `// Auto-generated by donkeylabs generate
-import { type Register, type InferService, type InferSchema, type InferHandlers, type InferMiddleware, type InferDependencies } from "@donkeylabs/server";
-${importLines}
-
-declare module "@donkeylabs/server" {
-  export interface PluginRegistry {
-${pluginRegistryEntries}
-  }
-
-  export interface PluginHandlerRegistry extends
-    ${handlerExtensions}
-  {}
-
-  export interface PluginMiddlewareRegistry extends
-    ${middlewareExtensions}
-  {}
-}
-
-export type AvailableHandlers = ${handlerUnion};
-export type AvailableMiddleware = ${middlewareUnion};
-
-declare module "@donkeylabs/server" {
-  export interface IRouteBuilder<TRouter> {
-${routeBuilderMethods}
-  }
-
-  export interface IMiddlewareBuilder<TRouter> {
-${middlewareBuilderMethods}
-  }
-}
-`;
-
-  await writeFile(join(outPath, "registry.d.ts"), content);
-}
-
-async function generateContext(
-  plugins: { name: string; path: string; exportName: string }[],
-  outPath: string
-) {
-  const schemaIntersection =
-    plugins.map((p) => `PluginRegistry["${p.name}"]["schema"]`).join(" & ") ||
-    "{}";
-
-  const content = `// Auto-generated by donkeylabs generate
-// App context - import as: import type { AppContext } from ".@donkeylabs/server/context";
-
-/// <reference path="./registry.d.ts" />
-import type { PluginRegistry, CoreServices, Errors } from "@donkeylabs/server";
-import type { Kysely } from "kysely";
-
-/** Merged database schema from all plugins */
-export type DatabaseSchema = ${schemaIntersection};
-
-/**
- * Fully typed application context.
- * Use this instead of ServerContext for typed plugin access.
- */
-export interface AppContext {
-  /** Database with merged schema from all plugins */
-  db: Kysely<DatabaseSchema>;
-  /** Typed plugin services */
-  plugins: {
-    [K in keyof PluginRegistry]: PluginRegistry[K]["service"];
-  };
-  /** Core services (logger, cache, events, etc.) */
-  core: Omit<CoreServices, "db" | "config" | "errors">;
-  /** Error factories (BadRequest, NotFound, etc.) */
-  errors: Errors;
-  /** Application config */
-  config: Record<string, any>;
-  /** Client IP address */
-  ip: string;
-  /** Unique request ID */
-  requestId: string;
-  /** Authenticated user (set by auth middleware) */
-  user?: any;
-}
-
-// Re-export as GlobalContext for backwards compatibility
-export type GlobalContext = AppContext;
-`;
-
-  await writeFile(join(outPath, "context.d.ts"), content);
-}
-
-// Route file structure: /src/routes/<namespace>/<route-name>/schema.ts
-interface RouteInfo {
-  namespace: string;
-  name: string;
-  schemaPath: string;
-}
-
-async function findRoutes(_pattern: string): Promise<RouteInfo[]> {
-  const routes: RouteInfo[] = [];
-  const routesDir = join(process.cwd(), "src/routes");
-
-  if (!existsSync(routesDir)) {
-    return routes;
-  }
-
-  // Scan routes directory structure: /routes/<namespace>/<route>/schema.ts
-  const namespaces = await readdir(routesDir, { withFileTypes: true });
-
-  for (const ns of namespaces) {
-    if (!ns.isDirectory() || ns.name.startsWith(".")) continue;
-
-    const namespaceDir = join(routesDir, ns.name);
-    const routeDirs = await readdir(namespaceDir, { withFileTypes: true });
-
-    for (const routeDir of routeDirs) {
-      if (!routeDir.isDirectory() || routeDir.name.startsWith(".")) continue;
-
-      const schemaPath = join(namespaceDir, routeDir.name, "schema.ts");
-
-      if (!existsSync(schemaPath)) continue;
-
-      routes.push({
-        namespace: ns.name,
-        name: routeDir.name,
-        schemaPath: relative(process.cwd(), schemaPath),
-      });
-    }
-  }
-
-  return routes;
-}
-
-function toPascalCase(str: string): string {
-  return str
-    .replace(/-([a-z])/g, (_, c) => c.toUpperCase())
-    .replace(/^./, (c) => c.toUpperCase());
-}
-
-async function generateRouteTypes(routes: RouteInfo[], outPath: string): Promise<void> {
-  // Group routes by namespace
-  const byNamespace = new Map<string, RouteInfo[]>();
-  for (const route of routes) {
-    if (!byNamespace.has(route.namespace)) {
-      byNamespace.set(route.namespace, []);
-    }
-    byNamespace.get(route.namespace)!.push(route);
-  }
-
-  // Generate imports for each route's schema (relative to outPath)
-  const imports: string[] = [];
-  for (const route of routes) {
-    // Calculate relative path from .@donkeylabs/server/ to src/routes/.../schema
-    const schemaAbsPath = join(process.cwd(), route.schemaPath).replace(/\.ts$/, "");
-    const outAbsPath = outPath;
-    const relativePath = relative(outAbsPath, schemaAbsPath);
-    const alias = `${toPascalCase(route.namespace)}_${toPascalCase(route.name)}`;
-    imports.push(`import { Input as ${alias}_Input, Output as ${alias}_Output } from "${relativePath}";`);
-  }
-
-  // Generate namespace declarations
-  const namespaceBlocks: string[] = [];
-  for (const [namespace, nsRoutes] of byNamespace) {
-    const pascalNamespace = toPascalCase(namespace);
-
-    const routeExports = nsRoutes.map((r) => {
-      const pascalRoute = toPascalCase(r.name);
-      const alias = `${pascalNamespace}_${pascalRoute}`;
-      return `  export namespace ${pascalRoute} {
-    /** Zod schema for input validation */
-    export const Input = ${alias}_Input;
-    /** Zod schema for output validation */
-    export const Output = ${alias}_Output;
-    /** TypeScript type for input data */
-    export type Input = z.infer<typeof ${alias}_Input>;
-    /** TypeScript type for output data */
-    export type Output = z.infer<typeof ${alias}_Output>;
-  }
-  /** Route contract type - use with Route<${pascalNamespace}.${pascalRoute}> and Handler<${pascalNamespace}.${pascalRoute}> */
-  export type ${pascalRoute} = { input: ${pascalRoute}.Input; output: ${pascalRoute}.Output };`;
-    }).join("\n\n");
-
-    namespaceBlocks.push(`export namespace ${pascalNamespace} {\n${routeExports}\n}`);
-  }
-
-  const content = `// Auto-generated by donkeylabs generate
-// Route Input/Output types - import as: import { Health } from ".@donkeylabs/server/routes";
-
-import { z } from "zod";
-import type { AppContext } from "./context";
-${imports.join("\n")}
-
-${namespaceBlocks.join("\n\n")}
-`;
-
-  await writeFile(join(outPath, "routes.ts"), content);
-}
-
-async function generateClient(
-  routes: RouteInfo[],
-  plugins: { name: string; path: string; exportName: string }[],
-  outputPath: string
-): Promise<void> {
-  // Group routes by namespace
-  const byNamespace = new Map<string, RouteInfo[]>();
-  for (const route of routes) {
-    if (!byNamespace.has(route.namespace)) {
-      byNamespace.set(route.namespace, []);
-    }
-    byNamespace.get(route.namespace)!.push(route);
-  }
-
-  // Generate method definitions
-  const namespaceBlocks: string[] = [];
-
-  for (const [namespace, nsRoutes] of byNamespace) {
-    // All routes are treated as typed by default
-    const methods = nsRoutes.map((r) => {
-      const methodName = r.name.replace(/-([a-z])/g, (_: string, c: string) => c.toUpperCase());
-      return `    ${methodName}: (input: any) => this.request("${namespace}.${r.name}", input)`;
-    });
-
-    if (methods.length > 0) {
-      namespaceBlocks.push(`  ${namespace} = {\n${methods.join(",\n")}\n  };`);
-    }
-  }
-
-  const content = `// Auto-generated by donkeylabs generate
-// API Client
-
-import { ApiClientBase } from "@donkeylabs/server/client";
-
-export class ApiClient extends ApiClientBase<{}> {
-  constructor(baseUrl: string, options?: RequestInit) {
-    super(baseUrl, options);
-  }
-
-${namespaceBlocks.join("\n\n") || "  // No routes defined"}
-}
-
-export function createApiClient(baseUrl: string, options?: RequestInit) {
-  return new ApiClient(baseUrl, options);
-}
-`;
-
-  const outputDir = dirname(outputPath);
-  await mkdir(outputDir, { recursive: true });
-  await writeFile(outputPath, content);
-}

package/examples/starter/node_modules/@donkeylabs/server/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(),
-  },
-});
-`;
-}