@donkeylabs/server 0.1.3 → 0.1.4

package/examples/starter/node_modules/@donkeylabs/server/README.md

@@ -0,0 +1,15 @@
+# plugin
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

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

@@ -0,0 +1,461 @@
+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> {
+  console.log(pc.bold("\nGenerating types...\n"));
+
+  const config = await loadConfig();
+  const outDir = config.outDir || ".@donkeylabs/server";
+  const outPath = join(process.cwd(), outDir);
+
+  await mkdir(outPath, { recursive: true });
+
+  // 1. Find and process plugins
+  const plugins = await findPlugins(config.plugins);
+
+  if (plugins.length === 0) {
+    console.log(
+      pc.yellow("No plugins found matching patterns:"),
+      config.plugins.join(", ")
+    );
+  } else {
+    console.log(pc.dim(`Found ${plugins.length} plugin(s):`));
+    for (const p of plugins) {
+      console.log(pc.dim(`  - ${p.name} (${p.exportName})`));
+    }
+    console.log();
+  }
+
+  // 2. Find and process routes
+  const routes = await findRoutes(config.routes || "./src/routes/**/handler.ts");
+  if (routes.length > 0) {
+    console.log(pc.dim(`Found ${routes.length} route(s):`));
+    for (const r of routes) {
+      console.log(pc.dim(`  - ${r.namespace}.${r.name}`));
+    }
+    console.log();
+  }
+
+  // 3. Generate registry and context
+  await generateRegistry(plugins, outPath);
+  await generateContext(plugins, outPath);
+  await generateRouteTypes(routes, outPath);
+
+  // 4. Generate client if configured
+  if (config.client?.output) {
+    console.log(pc.dim("\nGenerating client..."));
+    await generateClient(routes, plugins, config.client.output);
+  }
+
+  console.log(pc.green("\nTypes generated successfully!"));
+}
+
+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 middlewareBuilderMethods = allMiddleware
+    .map(
+      ({ plugin, middleware }) => `    /** Middleware from ${plugin} */
+    ${middleware}(config?: InferMiddleware<typeof ${plugin}>["${middleware}"]["__config"]): this;`
+    )
+    .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";
+
+  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);
+  console.log(pc.green("  Generated:"), `${outPath}/registry.d.ts`);
+}
+
+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
+
+/// <reference path="./registry.d.ts" />
+import type { PluginRegistry, CoreServices, Errors } from "@donkeylabs/server";
+import type { Kysely } from "kysely";
+
+type DatabaseSchema = ${schemaIntersection};
+
+export interface GlobalContext {
+  db: Kysely<DatabaseSchema>;
+  plugins: {
+    [K in keyof PluginRegistry]: PluginRegistry[K]["service"];
+  };
+  core: CoreServices;
+  errors: Errors;
+  ip: string;
+  requestId?: string;
+  user?: any;
+}
+`;
+
+  await writeFile(join(outPath, "context.d.ts"), content);
+  console.log(pc.green("  Generated:"), `${outPath}/context.d.ts`);
+}
+
+// Route file structure: /src/routes/<namespace>/<route-name>/handler.ts
+interface RouteInfo {
+  namespace: string;
+  name: string;
+  path: string;
+  handlerType: "typed" | "raw";
+  inputSchema?: string;
+  outputSchema?: 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>/handler.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 handlerPath = join(namespaceDir, routeDir.name, "handler.ts");
+      if (!existsSync(handlerPath)) continue;
+
+      const content = await readFile(handlerPath, "utf-8");
+
+      // Extract handler type and schemas
+      const handlerType = content.includes(".raw(") ? "raw" : "typed";
+
+      // Extract input/output schemas for typed handlers
+      let inputSchema: string | undefined;
+      let outputSchema: string | undefined;
+
+      if (handlerType === "typed") {
+        const inputMatch = content.match(/input:\s*(z\.[^,\n]+)/);
+        const outputMatch = content.match(/output:\s*(z\.[^,\n]+)/);
+        inputSchema = inputMatch?.[1];
+        outputSchema = outputMatch?.[1];
+      }
+
+      routes.push({
+        namespace: ns.name,
+        name: routeDir.name,
+        path: relative(process.cwd(), handlerPath),
+        handlerType,
+        inputSchema,
+        outputSchema,
+      });
+    }
+  }
+
+  return routes;
+}
+
+async function generateRouteTypes(routes: RouteInfo[], outPath: string): Promise<void> {
+  if (routes.length === 0) return;
+
+  // 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 route imports
+  const imports = routes.map((r) =>
+    `import type { handler as ${r.namespace}_${r.name} } from "${join(process.cwd(), r.path).replace(/\.ts$/, "")}";`
+  ).join("\n");
+
+  // Generate namespace types
+  const namespaceBlocks: string[] = [];
+  for (const [namespace, nsRoutes] of byNamespace) {
+    const routeTypes = nsRoutes.map((r) => {
+      const pascalName = r.name.replace(/-([a-z])/g, (_, c) => c.toUpperCase()).replace(/^./, (c) => c.toUpperCase());
+      return `    ${r.name}: typeof ${namespace}_${r.name};`;
+    }).join("\n");
+
+    namespaceBlocks.push(`  ${namespace}: {\n${routeTypes}\n  };`);
+  }
+
+  const content = `// Auto-generated by donkeylabs generate
+// Route type definitions
+
+${imports}
+
+export interface RouteHandlers {
+${namespaceBlocks.join("\n")}
+}
+
+export type RouteNamespace = keyof RouteHandlers;
+export type RouteName<NS extends RouteNamespace> = keyof RouteHandlers[NS];
+`;
+
+  await writeFile(join(outPath, "routes.d.ts"), content);
+  console.log(pc.green("  Generated:"), `${outPath}/routes.d.ts`);
+}
+
+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) {
+    const methods = nsRoutes
+      .filter((r) => r.handlerType === "typed")
+      .map((r) => {
+        const methodName = r.name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        return `    ${methodName}: (input: any) => this.request("${namespace}.${r.name}", input)`;
+      });
+
+    const rawMethods = nsRoutes
+      .filter((r) => r.handlerType === "raw")
+      .map((r) => {
+        const methodName = r.name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+        return `    ${methodName}: (init?: RequestInit) => this.rawRequest("${namespace}.${r.name}", init)`;
+      });
+
+    if (methods.length > 0 || rawMethods.length > 0) {
+      namespaceBlocks.push(`  ${namespace} = {\n${[...methods, ...rawMethods].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);
+  console.log(pc.green("  Generated:"), outputPath);
+}