@donkeylabs/server 0.2.9 → 0.2.11

package/examples/starter/node_modules/@donkeylabs/server/src/handlers.ts

@@ -1,182 +0,0 @@
-import type { RouteDefinition, ServerContext } from "./router";
-import { z } from "zod";
-
-// ============================================
-// Route and Handler Types for DX
-// ============================================
-
-/**
- * Route contract interface - generated routes export this shape
- */
-export interface RouteContract {
-  input: any;
-  output: any;
-}
-
-/**
- * Handler interface for model classes.
- *
- * @example
- * import type { Handler } from "@donkeylabs/server";
- * import type { Health } from "$server/routes";
- *
- * export class PingModel implements Handler<Health.Ping> {
- *   handle(input: Health.Ping.Input): Health.Ping.Output {
- *     return { status: "ok", timestamp: new Date().toISOString() };
- *   }
- * }
- */
-export interface Handler<T extends RouteContract> {
-  handle(input: T["input"]): T["output"] | Promise<T["output"]>;
-}
-
-/**
- * Typed route definition.
- * Use with generated route types: `const route: Route<Health.Ping> = { ... }`
- *
- * @example
- * import { Health } from ".@donkeylabs/server/routes";
- * import type { Route } from "@donkeylabs/server";
- *
- * export const pingRoute: Route<Health.Ping> = {
- *   input: Health.Ping.Input,
- *   output: Health.Ping.Output,
- *   handle: async (input, ctx) => new PingModel(ctx).handle(input),
- * };
- */
-export interface Route<T extends RouteContract> {
-  input: z.ZodType<T["input"]>;
-  output: z.ZodType<T["output"]>;
-  handle: (input: T["input"], ctx: ServerContext) => T["output"] | Promise<T["output"]>;
-}
-
-/**
- * Route configuration with inferred types from zod schemas.
- */
-export interface TypedRouteConfig<TInput, TOutput> {
-  input: z.ZodType<TInput>;
-  output: z.ZodType<TOutput>;
-  handle: (input: TInput, ctx: ServerContext) => TOutput | Promise<TOutput>;
-}
-
-export interface RawRouteConfig {
-  handle: (req: Request, ctx: ServerContext) => Response | Promise<Response>;
-}
-
-/**
- * Create a typed route with full type inference from zod schemas.
- *
- * @example
- * export const pingRoute = createRoute.typed({
- *   input: z.object({ echo: z.string().optional() }),
- *   output: z.object({ status: z.literal("ok"), timestamp: z.string() }),
- *   handle: async (input, ctx) => ({
- *     status: "ok",
- *     timestamp: new Date().toISOString(),
- *   }),
- * });
- */
-export const createRoute = {
-  typed<TInput, TOutput>(config: TypedRouteConfig<TInput, TOutput>) {
-    return {
-      ...config,
-      _handler: "typed" as const,
-    };
-  },
-
-  raw(config: RawRouteConfig) {
-    return {
-      ...config,
-      _handler: "raw" as const,
-    };
-  },
-};
-
-// ============================================
-// Handler Runtimes
-// ============================================
-
-export interface HandlerRuntime<Fn extends Function = Function> {
-  execute(
-    req: Request,
-    def: RouteDefinition<any, any>,
-    userHandle: Fn,
-    ctx: ServerContext
-  ): Promise<Response>;
-
-  readonly __signature: Fn;  // Required for type inference
-}
-
-/**
- * Factory function to create custom handlers without manual __signature.
- *
- * @example
- * type EchoFn = (body: any, ctx: ServerContext) => Promise<{ echo: any }>;
- *
- * export const EchoHandler = createHandler<EchoFn>(async (req, def, handle, ctx) => {
- *   const body = await req.json();
- *   const result = await handle(body, ctx);
- *   return Response.json(result);
- * });
- */
-export function createHandler<Fn extends Function>(
-  execute: (
-    req: Request,
-    def: RouteDefinition<any, any>,
-    handle: Fn,
-    ctx: ServerContext
-  ) => Promise<Response>
-): HandlerRuntime<Fn> {
-  return {
-    execute,
-    __signature: undefined as unknown as Fn
-  };
-}
-
-export type TypedFn = (input: any, ctx: ServerContext) => Promise<any> | any;
-export type TypedHandler = HandlerRuntime<TypedFn>;
-
-export const TypedHandler: TypedHandler = {
-  async execute(req, def, handle, ctx) {
-      if (req.method !== "POST") {
-        return new Response("Method Not Allowed", { status: 405 });
-      }
-
-      let body: unknown = {};
-      try {
-        body = await req.json();
-      } catch {
-        return Response.json({ error: "Invalid JSON" }, { status: 400 });
-      }
-
-      try {
-        const input = def.input ? def.input.parse(body) : body;
-        const result = await handle(input, ctx);
-        const output = def.output ? def.output.parse(result) : result;
-        return Response.json(output);
-      } catch (e) {
-         console.error(e);
-         if (e instanceof z.ZodError) {
-             return Response.json({ error: "Validation Failed", details: e.issues }, { status: 400 });
-         }
-         const message = e instanceof Error ? e.message : "Internal Error";
-         return Response.json({ error: message }, { status: 500 });
-      }
-  },
-  __signature: undefined as unknown as TypedFn
-};
-
-export type RawFn = (req: Request, ctx: ServerContext) => Promise<Response> | Response;
-export type RawHandler = HandlerRuntime<RawFn>;
-
-export const RawHandler: RawHandler = {
-  async execute(req, def, handle, ctx) {
-     return await handle(req, ctx);
-  },
-  __signature: undefined as unknown as RawFn
-};
-
-export const Handlers = {
-    typed: TypedHandler,
-    raw: RawHandler
-};

package/examples/starter/node_modules/@donkeylabs/server/src/harness.ts

@@ -1,70 +0,0 @@
-import { Kysely } from "kysely";
-import { BunSqliteDialect } from "kysely-bun-sqlite";
-import { Database } from "bun:sqlite";
-import { PluginManager, type Plugin, type CoreServices } from "./core";
-import {
-  createLogger,
-  createCache,
-  createEvents,
-  createCron,
-  createJobs,
-  createSSE,
-  createRateLimiter,
-  createErrors,
-} from "./core/index";
-
-/**
- * Creates a fully functional (in-memory) testing environment for a plugin.
- *
- * @param targetPlugin The plugin you want to test.
- * @param dependencies Any other plugins this plugin needs (e.g. Auth).
- */
-export async function createTestHarness(targetPlugin: Plugin, dependencies: Plugin[] = []) {
-  // 1. Setup In-Memory DB
-  const db = new Kysely<any>({
-    dialect: new BunSqliteDialect({ database: new Database(":memory:") }),
-  });
-
-  // 2. Initialize Core Services
-  const logger = createLogger({ level: "warn" }); // Less verbose in tests
-  const cache = createCache();
-  const events = createEvents();
-  const cron = createCron();
-  const jobs = createJobs({ events });
-  const sse = createSSE();
-  const rateLimiter = createRateLimiter();
-  const errors = createErrors();
-
-  const core: CoreServices = {
-    db,
-    config: { env: "test" },
-    logger,
-    cache,
-    events,
-    cron,
-    jobs,
-    sse,
-    rateLimiter,
-    errors,
-  };
-
-  const manager = new PluginManager(core);
-
-  // 3. Register Deps + Target
-  for (const dep of dependencies) {
-    manager.register(dep);
-  }
-  manager.register(targetPlugin);
-
-  // 4. Run Migrations (Real Kysely Migrations!)
-  await manager.migrate();
-
-  // 5. Init Plugins
-  await manager.init();
-
-  return {
-    manager,
-    db,
-    core
-  };
-}

package/examples/starter/node_modules/@donkeylabs/server/src/index.ts

@@ -1,51 +0,0 @@
-// @donkeylabs/server - Main exports
-
-// Server
-export { AppServer, type ServerConfig } from "./server";
-
-// Router
-export { createRouter, type Router, type RouteBuilder, type ServerContext, type IRouter, type IRouteBuilder, type IMiddlewareBuilder } from "./router";
-
-// Handlers and Route types
-export {
-  createHandler,
-  createRoute,
-  TypedHandler,
-  RawHandler,
-  type Handler,
-  type Route,
-  type RouteContract,
-} from "./handlers";
-
-// Core Plugin System
-export {
-  createPlugin,
-  PluginManager,
-  PluginContext,
-  type PluginRegistry,
-  type PluginHandlerRegistry,
-  type PluginMiddlewareRegistry,
-  type CoreServices,
-  type Register,
-  type InferService,
-  type InferSchema,
-  type InferHandlers,
-  type InferMiddleware,
-  type InferDependencies,
-} from "./core";
-
-// Middleware
-export { createMiddleware } from "./middleware";
-
-// Config helper
-export function defineConfig(config: {
-  plugins: string[];
-  outDir: string;
-  routes?: string;
-  client?: { output: string };
-}) {
-  return config;
-}
-
-// Re-export HttpError for custom error creation
-export { HttpError } from "./core/errors";

package/examples/starter/node_modules/@donkeylabs/server/src/middleware.ts

@@ -1,34 +0,0 @@
-import type { ServerContext } from "./router";
-
-// The next function - calls the next middleware or handler
-export type NextFn = () => Promise<Response>;
-
-// Middleware function signature (what plugins implement)
-export type MiddlewareFn<TConfig = void> = (
-  req: Request,
-  ctx: ServerContext,
-  next: NextFn,
-  config: TConfig
-) => Promise<Response>;
-
-// Runtime middleware structure (mirrors HandlerRuntime pattern)
-export interface MiddlewareRuntime<TConfig = void> {
-  execute: MiddlewareFn<TConfig>;
-  readonly __config: TConfig; // Phantom type for config inference
-}
-
-// Factory to create middleware (mirrors createHandler pattern)
-export function createMiddleware<TConfig = void>(
-  execute: MiddlewareFn<TConfig>
-): MiddlewareRuntime<TConfig> {
-  return {
-    execute,
-    __config: undefined as unknown as TConfig,
-  };
-}
-
-// Stored middleware definition (attached to routes)
-export interface MiddlewareDefinition {
-  name: string;
-  config: any;
-}

package/examples/starter/node_modules/@donkeylabs/server/src/registry.ts

@@ -1,13 +0,0 @@
-// Auto-generated by scripts/generate-registry.ts
-// Runtime registration of custom handler and middleware methods
-/// <reference path="../registry.d.ts" />
-import { RouteBuilder, MiddlewareBuilder } from "./router";
-
-// Handler registrations
-
-
-// Middleware registrations
-// Register "authRequired" middleware method from authPlugin
-(MiddlewareBuilder.prototype as any).authRequired = function(config: any = {}) {
-  return this.addMiddleware("authRequired", config);
-};

package/examples/starter/node_modules/@donkeylabs/server/src/router.ts

@@ -1,172 +0,0 @@
-/// <reference path="../registry.d.ts" />
-import { z } from "zod";
-import type { GlobalContext } from "../context";
-import type { PluginHandlerRegistry } from "./core";
-import type { MiddlewareDefinition } from "./middleware";
-
-export type ServerContext = GlobalContext;
-
-/** Base interface for middleware builder - extended by generated types */
-export interface IMiddlewareBuilder<TRouter> {}
-
-export interface HandlerRegistry extends PluginHandlerRegistry {
-    typed: {
-        execute(req: Request, def: any, userHandle: Function, ctx: ServerContext): Promise<Response>;
-        readonly __signature: (input: any, ctx: ServerContext) => Promise<any> | any;
-    };
-    raw: {
-        execute(req: Request, def: any, userHandle: Function, ctx: ServerContext): Promise<Response>;
-        readonly __signature: (req: Request, ctx: ServerContext) => Promise<Response> | Response;
-    };
-}
-
-export type RouteDefinition<
-    T extends keyof HandlerRegistry = "typed",
-    I = any,
-    O = any
-> = {
-  name: string;
-  handler: T;
-  input?: z.ZodType<I>;
-  output?: z.ZodType<O>;
-  middleware?: MiddlewareDefinition[];
-  handle: T extends "typed"
-    ? (input: I, ctx: ServerContext) => Promise<O> | O
-    : T extends "raw"
-    ? (req: Request, ctx: ServerContext) => Promise<Response> | Response
-    : HandlerRegistry[T]["__signature"];
-};
-
-export interface TypedRouteConfig<I = any, O = any> {
-  input?: z.ZodType<I>;
-  output?: z.ZodType<O>;
-  handle: (input: I, ctx: ServerContext) => Promise<O> | O;
-}
-
-export interface RouteMetadata {
-  name: string;
-  handler: string;
-  inputSchema?: z.ZodType<any>;
-  outputSchema?: z.ZodType<any>;
-}
-
-export interface RawRouteConfig {
-  handle: (req: Request, ctx: ServerContext) => Promise<Response> | Response;
-}
-
-export interface IRouteBuilderBase<TRouter> {
-  typed<I, O>(config: TypedRouteConfig<I, O>): TRouter;
-  raw(config: RawRouteConfig): TRouter;
-}
-
-export interface IRouteBuilder<TRouter> extends IRouteBuilderBase<TRouter> {}
-
-
-export class RouteBuilder<TRouter extends Router> implements IRouteBuilderBase<TRouter> {
-  constructor(
-    private router: TRouter,
-    private name: string,
-    private _middleware: MiddlewareDefinition[] = []
-  ) {}
-
-  typed<I, O>(config: TypedRouteConfig<I, O>): TRouter {
-    return this.router.addRoute(this.name, "typed", config, this._middleware);
-  }
-
-  raw(config: RawRouteConfig): TRouter {
-    return this.router.addRoute(this.name, "raw", config, this._middleware);
-  }
-
-  addHandler(handler: string, config: any): TRouter {
-    return this.router.addRoute(this.name, handler, config, this._middleware);
-  }
-}
-
-export interface IRouter {
-  route(name: string): IRouteBuilder<this>;
-  router(prefixOrRouter: string | IRouter): IRouter;
-  middleware: IMiddlewareBuilder<this>;
-  getRoutes(): RouteDefinition<any, any, any>[];
-  getMetadata(): RouteMetadata[];
-  getPrefix(): string;
-}
-
-export class Router implements IRouter {
-  private routes: Map<string, RouteDefinition<any, any, any>> = new Map();
-  private prefix: string;
-  private _middlewareStack: MiddlewareDefinition[] = [];
-
-  constructor(prefix: string = "") {
-    this.prefix = prefix;
-  }
-
-  route(name: string): IRouteBuilder<this> {
-    return new RouteBuilder(this, name, this._middlewareStack) as unknown as IRouteBuilder<this>;
-  }
-
-  /** Create a nested router or register a child router */
-  router(prefixOrRouter: string | IRouter): IRouter {
-    if (typeof prefixOrRouter === "string") {
-      const fullPrefix = this.prefix ? `${this.prefix}.${prefixOrRouter}` : prefixOrRouter;
-      const childRouter = new Router(fullPrefix);
-      childRouter._middlewareStack = [...this._middlewareStack];
-      return childRouter;
-    }
-    // Merge child router's routes into this router
-    for (const route of prefixOrRouter.getRoutes()) {
-      const fullName = this.prefix ? `${this.prefix}.${route.name}` : route.name;
-      this.routes.set(fullName, { ...route, name: fullName, middleware: [...this._middlewareStack, ...(route.middleware || [])] });
-    }
-    return this;
-  }
-
-  /** Middleware builder - chain middleware before defining routes */
-  get middleware(): IMiddlewareBuilder<this> {
-    return createMiddlewareBuilderProxy(this);
-  }
-
-  addRoute(name: string, handler: string, config: any, middleware: MiddlewareDefinition[] = []): this {
-    const fullName = this.prefix ? `${this.prefix}.${name}` : name;
-    this.routes.set(fullName, {
-      name: fullName,
-      handler,
-      middleware: middleware.length > 0 ? middleware : undefined,
-      ...config
-    });
-    return this;
-  }
-
-  getRoutes(): RouteDefinition<any, any, any>[] {
-    return Array.from(this.routes.values());
-  }
-
-  getMetadata(): RouteMetadata[] {
-    return this.getRoutes().map(route => ({
-      name: route.name,
-      handler: route.handler,
-      inputSchema: route.input,
-      outputSchema: route.output,
-    }));
-  }
-
-  getPrefix(): string {
-    return this.prefix;
-  }
-}
-
-/** Creates a Proxy that intercepts middleware method calls and adds them to the router's middleware stack */
-function createMiddlewareBuilderProxy<TRouter extends Router>(router: TRouter): IMiddlewareBuilder<TRouter> {
-  return new Proxy({} as IMiddlewareBuilder<TRouter>, {
-    get(_target, prop) {
-      if (typeof prop === "string") {
-        return (config?: any) => {
-          router["_middlewareStack"].push({ name: prop, config });
-          return router;
-        };
-      }
-      return undefined;
-    },
-  });
-}
-
-export const createRouter = (prefix?: string): IRouter => new Router(prefix);